fix: Improve boundary gap mitigation at DASH period transitions (#8344)

With resetting MSE on boundary crossing, we might seek into a gap. This
would cause MSE not to reset properly, and playback will stall. The
following changes are made:

- We rely on `seeking` to check if we need to start the boundary timer.
The timer assumes we will cross a boundary in a short period of time,
and is built to handle edge cases like misalignment & subtle gaps. We
first relied on `seeked` but that event might never come when MSE does
not reset. Thus seeking into a gap near a boundary end would have never
spawned the timer in the first place, leaving the player endlessly
stalling.
- When crossing a boundary, the MSE resets but never completes (as
explained earlier). In this case, the timer will advance the playhead.
However, due to the incomplete MSE reset, the video element remains
paused. Since the previous state was paused, playback does not resume
automatically after crossing the boundary. I now keep a variable that
indicates we need to resume playback when MSE reset completes.

Author: matvp91

lib/media/media_source_engine.js

@@ -145,6 +145,9 @@ shaka.media.MediaSourceEngine = class {
     /** @private {boolean} */
     this.reloadingMediaSource_ = false;
 
+    /** @private {boolean} */
+    this.playAfterReset_ = false;
+
     /** @type {!shaka.util.Destroyer} */
     this.destroyer_ = new shaka.util.Destroyer(() => this.doDestroy_());
 
@@ -2254,7 +2257,9 @@ shaka.media.MediaSourceEngine = class {
     // Playing can also end up in a paused state after a codec switch
     // so we need to remember the current states.
     const previousAutoPlayState = this.video_.autoplay;
-    const previousPausedState = this.video_.paused;
+    if (!this.video_.paused) {
+      this.playAfterReset_ = true;
+    }
     if (this.playbackHasBegun_) {
       // Only set autoplay to false if the video playback has already begun.
       // When a codec switch happens before playback has begun this can cause
@@ -2337,7 +2342,8 @@ shaka.media.MediaSourceEngine = class {
         }
 
         this.video_.autoplay = previousAutoPlayState;
-        if (!previousPausedState) {
+        if (this.playAfterReset_) {
+          this.playAfterReset_ = false;
           this.video_.play();
         }
       });

lib/media/streaming_engine.js

@@ -917,6 +917,13 @@ shaka.media.StreamingEngine = class {
       }
     }
 
+    const CrossBoundaryStrategy = shaka.config.CrossBoundaryStrategy;
+    if (this.config_.crossBoundaryStrategy !== CrossBoundaryStrategy.KEEP) {
+      // We might have seeked near a boundary, forward time in case MSE does not
+      // recover due to segment misalignment near the boundary.
+      this.forwardTimeForCrossBoundary();
+    }
+
     if (!streamCleared) {
       shaka.log.debug(
           '(all): seeked: buffered seek: presentationTime=' + presentationTime);
@@ -3045,7 +3052,7 @@ shaka.media.StreamingEngine = class {
     const mediaState = this.mediaStates_.get(ContentType.VIDEO) ||
       this.mediaStates_.get(ContentType.AUDIO);
 
-    if (!mediaState || mediaState.clearingBuffer) {
+    if (!mediaState) {
       return;
     }
 
@@ -3131,9 +3138,14 @@ shaka.media.StreamingEngine = class {
           'from=', mediaState.lastInitSegmentReference,
           'to=', reference.initSegmentReference);
 
+      const video = this.playerInterface_.video;
+      const pausedBeforeReset = video.paused;
       this.resetMediaSource(/* force= */ true).then(() => {
         const eventName = shaka.util.FakeEvent.EventName.BoundaryCrossed;
         this.playerInterface_.onEvent(new shaka.util.FakeEvent(eventName));
+        if (!pausedBeforeReset) {
+          video.play();
+        }
       });
     }
     return discard;

lib/player.js

@@ -2625,8 +2625,6 @@ shaka.Player = class extends shaka.util.FakeEventTarget {
             () => forwardTimeForCrossBoundary(/* immediate= */ true));
         this.loadEventManager_.listen(mediaElement, 'timeupdate',
             () => forwardTimeForCrossBoundary());
-        this.loadEventManager_.listen(mediaElement, 'seeked',
-            () => forwardTimeForCrossBoundary());
       }
     }