Source: lib/media/gap_jumping_controller.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.GapJumpingController');
  9. goog.require('shaka.log');
  10. goog.require('shaka.media.PresentationTimeline');
  11. goog.require('shaka.media.StallDetector');
  12. goog.require('shaka.media.TimeRangesUtils');
  13. goog.require('shaka.util.EventManager');
  14. goog.require('shaka.util.FakeEvent');
  15. goog.require('shaka.util.IReleasable');
  16. goog.require('shaka.util.Platform');
  17. goog.require('shaka.util.Timer');
  20. /**
  21.  * GapJumpingController handles jumping gaps that appear within the content.
  22.  * This will only jump gaps between two buffered ranges, so we should not have
  23.  * to worry about the availability window.
  24.  *
  25.  * @implements {shaka.util.IReleasable}
  26.  */
  27. shaka.media.GapJumpingController = class {
  28.   /**
  29.    * @param {!HTMLMediaElement} video
  30.    * @param {!shaka.media.PresentationTimeline} timeline
  31.    * @param {shaka.extern.StreamingConfiguration} config
  32.    * @param {shaka.media.StallDetector} stallDetector
  33.    *   The stall detector is used to keep the playhead moving while in a
  34.    *   playable region. The gap jumping controller takes ownership over the
  35.    *   stall detector.
  36.    *   If no stall detection logic is desired, |null| may be provided.
  37.    * @param {function(!Event)} onEvent
  38.    *     Called when an event is raised to be sent to the application.
  39.    */
  40.   constructor(video, timeline, config, stallDetector, onEvent) {
  41.     /** @private {?function(!Event)} */
  42.     this.onEvent_ = onEvent;
  44.     /** @private {HTMLMediaElement} */
  45.     this.video_ = video;
  47.     /** @private {?shaka.media.PresentationTimeline} */
  48.     this.timeline_ = timeline;
  50.     /** @private {?shaka.extern.StreamingConfiguration} */
  51.     this.config_ = config;
  53.     /** @private {shaka.util.EventManager} */
  54.     this.eventManager_ = new shaka.util.EventManager();
  56.     /** @private {boolean} */
  57.     this.seekingEventReceived_ = false;
  59.     /** @private {number} */
  60.     this.prevReadyState_ = video.readyState;
  62.     /** @private {number} */
  63.     this.startTime_ = 0;
  65.     /** @private {number} */
  66.     this.gapsJumped_ = 0;
  68.     /**
  69.      * The stall detector tries to keep the playhead moving forward. It is
  70.      * managed by the gap-jumping controller to avoid conflicts. On some
  71.      * platforms, the stall detector is not wanted, so it may be null.
  72.      *
  73.      * @private {shaka.media.StallDetector}
  74.      */
  75.     this.stallDetector_ = stallDetector;
  77.     /** @private {boolean} */
  78.     this.hadSegmentAppended_ = false;
  80.     this.eventManager_.listen(video, 'waiting', () => this.onPollGapJump_());
  82.     /**
  83.      * We can't trust |readyState| or 'waiting' events on all platforms. To make
  84.      * up for this, we poll the current time. If we think we are in a gap, jump
  85.      * out of it.
  86.      *
  87.      * See: https://bit.ly/2McuXxm and https://bit.ly/2K5xmJO
  88.      *
  89.      * @private {?shaka.util.Timer}
  90.      */
  91.     this.gapJumpTimer_ = new shaka.util.Timer(() => {
  92.       this.onPollGapJump_();
  93.     }).tickEvery(this.config_.gapJumpTimerTime);
  94.   }
  97.   /** @override */
  98.   release() {
  99.     if (this.eventManager_) {
  100.       this.eventManager_.release();
  101.       this.eventManager_ = null;
  102.     }
  104.     if (this.gapJumpTimer_ != null) {
  105.       this.gapJumpTimer_.stop();
  106.       this.gapJumpTimer_ = null;
  107.     }
  109.     if (this.stallDetector_) {
  110.       this.stallDetector_.release();
  111.       this.stallDetector_ = null;
  112.     }
  114.     this.onEvent_ = null;
  115.     this.timeline_ = null;
  116.     this.video_ = null;
  117.   }
  120.   /**
  121.    * Called when a segment is appended by StreamingEngine, but not when a clear
  122.    * is pending. This means StreamingEngine will continue buffering forward from
  123.    * what is buffered.  So we know about any gaps before the start.
  124.    */
  125.   onSegmentAppended() {
  126.     this.hadSegmentAppended_ = true;
  127.     this.onPollGapJump_();
  128.   }
  130.   /**
  131.    * Called when playback has started and the video element is
  132.    * listening for seeks.
  133.    *
  134.    * @param {number} startTime
  135.    */
  136.   onStarted(startTime) {
  137.     if (this.video_.seeking && !this.seekingEventReceived_) {
  138.       this.seekingEventReceived_ = true;
  139.       this.startTime_ = startTime;
  140.     }
  141.   }
  143.   /** Called when a seek has started. */
  144.   onSeeking() {
  145.     this.seekingEventReceived_ = true;
  146.     this.hadSegmentAppended_ = false;
  147.   }
  150.   /**
  151.    * Returns the total number of playback gaps jumped.
  152.    * @return {number}
  153.    */
  154.   getGapsJumped() {
  155.     return this.gapsJumped_;
  156.   }
  159.   /**
  160.    * Called on a recurring timer to check for gaps in the media.  This is also
  161.    * called in a 'waiting' event.
  162.    *
  163.    * @private
  164.    */
  165.   onPollGapJump_() {
  166.     // Don't gap jump before the video is ready to play.
  167.     if (this.video_.readyState == 0) {
  168.       return;
  169.     }
  170.     // Do not gap jump if seeking has begun, but the seeking event has not
  171.     // yet fired for this particular seek.
  172.     if (this.video_.seeking) {
  173.       if (!this.seekingEventReceived_) {
  174.         return;
  175.       }
  176.     } else {
  177.       this.seekingEventReceived_ = false;
  178.     }
  179.     // Don't gap jump while paused, so that you don't constantly jump ahead
  180.     // while paused on a livestream.  We make an exception for time 0, since we
  181.     // may be _required_ to seek on startup before play can begin, but only if
  182.     // autoplay is enabled.
  183.     if (this.video_.paused && (this.video_.currentTime != this.startTime_ ||
  184.       (!this.video_.autoplay && this.video_.currentTime == this.startTime_))) {
  185.       return;
  186.     }
  189.     // When the ready state changes, we have moved on, so we should fire the
  190.     // large gap event if we see one.
  191.     if (this.video_.readyState != this.prevReadyState_) {
  192.       this.prevReadyState_ = this.video_.readyState;
  193.     }
  195.     if (this.stallDetector_ && this.stallDetector_.poll()) {
  196.       // Some action was taken by StallDetector, so don't do anything yet.
  197.       return;
  198.     }
  201.     const currentTime = this.video_.currentTime;
  202.     const buffered = this.video_.buffered;
  203.     const gapDetectionThreshold = this.config_.gapDetectionThreshold;
  205.     const gapIndex = shaka.media.TimeRangesUtils.getGapIndex(
  206.         buffered, currentTime, gapDetectionThreshold);
  208.     // The current time is unbuffered or is too far from a gap.
  209.     if (gapIndex == null) {
  210.       return;
  211.     }
  213.     // If we are before the first buffered range, this could be an unbuffered
  214.     // seek.  So wait until a segment is appended so we are sure it is a gap.
  215.     if (gapIndex == 0 && !this.hadSegmentAppended_) {
  216.       return;
  217.     }
  219.     // StreamingEngine can buffer past the seek end, but still don't allow
  220.     // seeking past it.
  221.     let jumpTo = buffered.start(gapIndex);
  222.     // Workaround for Xbox with Legacy Edge. On this platform video element
  223.     // often rounds value we want to set as currentTime and we are not able
  224.     // to jump over the gap.
  225.     if (shaka.util.Platform.isLegacyEdge() ||
  226.         shaka.util.Platform.isXboxOne()) {
  227.       jumpTo = Math.ceil((jumpTo + 0.01) * 100) / 100;
  228.     }
  229.     const seekEnd = this.timeline_.getSeekRangeEnd();
  230.     if (jumpTo >= seekEnd) {
  231.       return;
  232.     }
  234.     const jumpSize = jumpTo - currentTime;
  236.     // If we jump to exactly the gap start, we may detect a small gap due to
  237.     // rounding errors or browser bugs.  We can ignore these extremely small
  238.     // gaps since the browser should play through them for us.
  239.     if (jumpSize < shaka.media.GapJumpingController.BROWSER_GAP_TOLERANCE) {
  240.       return;
  241.     }
  243.     if (gapIndex == 0) {
  244.       shaka.log.info(
  245.           'Jumping forward', jumpSize,
  246.           'seconds because of gap before start time of', jumpTo);
  247.     } else {
  248.       shaka.log.info(
  249.           'Jumping forward', jumpSize, 'seconds because of gap starting at',
  250.           buffered.end(gapIndex - 1), 'and ending at', jumpTo);
  251.     }
  253.     this.video_.currentTime = jumpTo;
  254.     // This accounts for the possibility that we jump a gap at the start
  255.     // position but we jump _into_ another gap. By setting the start
  256.     // position to the new jumpTo we ensure that the check above will
  257.     // pass even though the video is still paused.
  258.     if (currentTime == this.startTime_) {
  259.       this.startTime_ = jumpTo;
  260.     }
  261.     this.gapsJumped_++;
  262.     this.onEvent_(
  263.         new shaka.util.FakeEvent(shaka.util.FakeEvent.EventName.GapJumped));
  264.   }
  265. };
  268. /**
  269.  * The limit, in seconds, for the gap size that we will assume the browser will
  270.  * handle for us.
  271.  * @const
  272.  */
  273. shaka.media.GapJumpingController.BROWSER_GAP_TOLERANCE = 0.001;