Eliminate JavaScript execution and setTimeout latency from playlist r…

…eload interval

src/controller/audio-track-controller.ts

@@ -240,6 +240,7 @@ class AudioTrackController extends BasePlaylistController {
   }
 
   protected loadPlaylist(hlsUrlParameters?: HlsUrlParameters): void {
+    super.loadPlaylist();
     const audioTrack = this.tracksInGroup[this.trackId];
     if (this.shouldLoadTrack(audioTrack)) {
       const id = audioTrack.id;

src/controller/base-playlist-controller.ts

@@ -17,6 +17,7 @@ import { ErrorTypes } from '../errors';
 export default class BasePlaylistController implements NetworkComponentAPI {
   protected hls: Hls;
   protected timer: number = -1;
+  protected requestScheduled: number = -1;
   protected canLoad: boolean = false;
   protected retryCount: number = 0;
   protected log: (msg: any) => void;
@@ -48,6 +49,7 @@ export default class BasePlaylistController implements NetworkComponentAPI {
   public startLoad(): void {
     this.canLoad = true;
     this.retryCount = 0;
+    this.requestScheduled = -1;
     this.loadPlaylist();
   }
 
@@ -89,7 +91,11 @@ export default class BasePlaylistController implements NetworkComponentAPI {
     }
   }
 
-  protected loadPlaylist(hlsUrlParameters?: HlsUrlParameters): void {}
+  protected loadPlaylist(hlsUrlParameters?: HlsUrlParameters): void {
+    if (this.requestScheduled === -1) {
+      this.requestScheduled = self.performance.now();
+    }
+  }
 
   protected shouldLoadTrack(track: MediaPlaylist): boolean {
     return (
@@ -108,8 +114,9 @@ export default class BasePlaylistController implements NetworkComponentAPI {
     const { details, stats } = data;
 
     // Set last updated date-time
-    const elapsed = stats.loading.end
-      ? Math.max(0, self.performance.now() - stats.loading.end)
+    const now = self.performance.now();
+    const elapsed = stats.loading.first
+      ? Math.max(0, now - stats.loading.first)
       : 0;
     details.advancedDateTime = Date.now() - elapsed;
 
@@ -204,22 +211,53 @@ export default class BasePlaylistController implements NetworkComponentAPI {
           part
         );
       }
-      const position = this.hls.mainForwardBufferInfo?.start || 0;
+      const bufferInfo = this.hls.mainForwardBufferInfo;
+      const position = bufferInfo ? bufferInfo.end - bufferInfo.len : 0;
       const distanceToLiveEdgeMs = (details.edge - position) * 1000;
-      let reloadInterval = computeReloadInterval(
+      const reloadInterval = computeReloadInterval(
         details,
-        stats,
         distanceToLiveEdgeMs
       );
+      if (!details.updated) {
+        this.requestScheduled = -1;
+      } else if (now > this.requestScheduled + reloadInterval) {
+        this.requestScheduled = stats.loading.start;
+      }
+
       if (msn !== undefined && details.canBlockReload) {
-        reloadInterval -= details.partTarget || 1;
+        this.requestScheduled =
+          stats.loading.first +
+          reloadInterval -
+          (details.partTarget * 1000 || 1000);
+      } else {
+        this.requestScheduled =
+          (this.requestScheduled === -1 ? now : this.requestScheduled) +
+          reloadInterval;
       }
+      let estimatedTimeUntilUpdate = this.requestScheduled - now;
+      estimatedTimeUntilUpdate = Math.max(0, estimatedTimeUntilUpdate);
       this.log(
-        `reload live playlist ${index} in ${Math.round(reloadInterval)} ms`
+        `reload live playlist ${index} in ${Math.round(
+          estimatedTimeUntilUpdate
+        )} ms`
       );
+      this.log(
+        `live reload ${details.updated ? 'REFRESHED' : 'MISSED'}
+  reload in ${estimatedTimeUntilUpdate / 1000}
+  round trip ${(stats.loading.end - stats.loading.start) / 1000}
+  diff ${
+    (reloadInterval -
+      (estimatedTimeUntilUpdate + stats.loading.end - stats.loading.start)) /
+    1000
+  }
+  reload interval ${reloadInterval / 1000}
+  target duration ${details.targetduration}
+  distance to edge ${distanceToLiveEdgeMs / 1000}`
+      );
+
       this.timer = self.setTimeout(
         () => this.loadPlaylist(deliveryDirectives),
-        reloadInterval
+        estimatedTimeUntilUpdate
       );
     } else {
       this.clearTimer();
@@ -245,6 +283,7 @@ export default class BasePlaylistController implements NetworkComponentAPI {
     const { config } = this.hls;
     const retry = this.retryCount < config.levelLoadingMaxRetry;
     if (retry) {
+      this.requestScheduled = -1;
       this.retryCount++;
       if (
         errorEvent.details.indexOf('LoadTimeOut') > -1 &&

src/controller/level-controller.ts

@@ -518,6 +518,7 @@ export default class LevelController extends BasePlaylistController {
   }
 
   protected loadPlaylist(hlsUrlParameters?: HlsUrlParameters) {
+    super.loadPlaylist();
     const level = this.currentLevelIndex;
     const currentLevel = this._levels[level];
 

src/controller/level-helper.ts

@@ -434,46 +434,29 @@ export function addSliding(details: LevelDetails, start: number) {
 
 export function computeReloadInterval(
   newDetails: LevelDetails,
-  stats: LoaderStats,
   distanceToLiveEdgeMs: number = Infinity
 ): number {
   let reloadInterval = 1000 * newDetails.targetduration;
 
-  // Use last segment duration when shorter than target duration and near live edge
-  const fragments = newDetails.fragments;
-  if (fragments.length && reloadInterval * 2 > distanceToLiveEdgeMs) {
-    const lastSegmentDuration = fragments[fragments.length - 1].duration * 1000;
-    if (lastSegmentDuration < reloadInterval) {
-      const now = performance.now();
-      reloadInterval = stats.loading.start + lastSegmentDuration - now;
+  if (newDetails.updated) {
+    // Use last segment duration when shorter than target duration and near live edge
+    const fragments = newDetails.fragments;
+    if (fragments.length && reloadInterval * 3 > distanceToLiveEdgeMs) {
+      const lastSegmentDuration =
+        fragments[fragments.length - 1].duration * 1000;
+      if (lastSegmentDuration < reloadInterval) {
+        reloadInterval = lastSegmentDuration;
+      }
     }
-  }
-
-  let estimatedTimeUntilUpdate;
-  if (!newDetails.updated) {
+  } else {
     // estimate = 'miss half average';
     // follow HLS Spec, If the client reloads a Playlist file and finds that it has not
     // changed then it MUST wait for a period of one-half the target
     // duration before retrying.
-    estimatedTimeUntilUpdate = reloadInterval / 2;
-  } else {
-    const roundTrip = stats.loading.end - stats.loading.start;
-    const now = performance.now();
-    const estimatedRefreshFromLastRequest =
-      stats.loading.start + reloadInterval - now;
-    estimatedTimeUntilUpdate = Math.min(
-      reloadInterval - roundTrip,
-      estimatedRefreshFromLastRequest
-    );
+    reloadInterval /= 2;
   }
 
-  // console.log(`[computeReloadInterval] live reload ${newDetails.updated ? 'REFRESHED' : 'MISSED'}`,
-  //   '\n  method', estimate,
-  //   '\n  estimated time until update =>', estimatedTimeUntilUpdate,
-  //   '\n  average target duration', reloadInterval,
-  //   '\n  time round trip', roundTrip);
-
-  return Math.round(estimatedTimeUntilUpdate);
+  return Math.round(reloadInterval);
 }
 
 export function getFragmentWithSN(

src/controller/subtitle-track-controller.ts

@@ -275,6 +275,7 @@ class SubtitleTrackController extends BasePlaylistController {
   }
 
   protected loadPlaylist(hlsUrlParameters?: HlsUrlParameters): void {
+    super.loadPlaylist();
     const currentTrack = this.tracksInGroup[this.trackId];
     if (this.shouldLoadTrack(currentTrack)) {
       const id = currentTrack.id;

tests/unit/controller/level-helper.ts

@@ -279,59 +279,41 @@ expect: ${JSON.stringify(merged.fragments[i])}`
       const newPlaylist = generatePlaylist([3, 4], 0, 6);
       newPlaylist.targetduration = 5;
       newPlaylist.updated = true;
-      const actual = computeReloadInterval(newPlaylist, new LoadStats());
+      const actual = computeReloadInterval(newPlaylist);
       expect(actual).to.equal(5000);
     });
 
     it('halves the reload interval if the playlist contains the same segments', function () {
       const newPlaylist = generatePlaylist([1, 2]);
       newPlaylist.updated = false;
       newPlaylist.targetduration = 5;
-      const actual = computeReloadInterval(newPlaylist, new LoadStats());
+      const actual = computeReloadInterval(newPlaylist);
       expect(actual).to.equal(2500);
     });
 
     it('rounds the reload interval', function () {
       const newPlaylist = generatePlaylist([3, 4], 0, 10);
       newPlaylist.targetduration = 5.9999;
       newPlaylist.updated = true;
-      const actual = computeReloadInterval(newPlaylist, new LoadStats());
+      const actual = computeReloadInterval(newPlaylist);
       expect(actual).to.equal(6000);
     });
 
-    it('subtracts the request time of the last level load from the reload interval', function () {
-      const newPlaylist = generatePlaylist([3, 4]);
-      newPlaylist.targetduration = 5;
-      newPlaylist.updated = true;
-      const stats = new LoadStats();
-      stats.loading.start = 0;
-      stats.loading.end = 1000;
-      const actual = computeReloadInterval(newPlaylist, stats);
-      expect(actual).to.equal(4000);
-    });
-
     it('returns a minimum of half the target duration', function () {
       const newPlaylist = generatePlaylist([3, 4]);
       newPlaylist.targetduration = 5;
       newPlaylist.updated = false;
-      const stats = new LoadStats();
-      stats.loading.start = 0;
-      stats.loading.end = 1000;
-      const actual = computeReloadInterval(newPlaylist, stats);
+      const actual = computeReloadInterval(newPlaylist);
       expect(actual).to.equal(2500);
     });
 
-    it('returns the last fragment duration when distance to live edge is less than two target durations', function () {
+    it('returns the last fragment duration when distance to live edge is less than three target durations', function () {
       const newPlaylist = generatePlaylist([3, 4], 0, 2);
       newPlaylist.targetduration = 5;
       newPlaylist.updated = true;
-      const actual = computeReloadInterval(newPlaylist, new LoadStats(), 11000);
+      const actual = computeReloadInterval(newPlaylist, 15000);
       expect(actual).to.equal(5000);
-      const actualLow = computeReloadInterval(
-        newPlaylist,
-        new LoadStats(),
-        9000
-      );
+      const actualLow = computeReloadInterval(newPlaylist, 14000);
       expect(actualLow).to.equal(2000);
     });
   });