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.started_ = false;
  59.     /** @private {boolean} */
  60.     this.seekingEventReceived_ = false;
  62.     /** @private {number} */
  63.     this.prevReadyState_ = video.readyState;
  65.     /** @private {number} */
  66.     this.startTime_ = 0;
  68.     /** @private {number} */
  69.     this.gapsJumped_ = 0;
  71.     /**
  72.      * The stall detector tries to keep the playhead moving forward. It is
  73.      * managed by the gap-jumping controller to avoid conflicts. On some
  74.      * platforms, the stall detector is not wanted, so it may be null.
  75.      *
  76.      * @private {shaka.media.StallDetector}
  77.      */
  78.     this.stallDetector_ = stallDetector;
  80.     /** @private {boolean} */
  81.     this.hadSegmentAppended_ = false;
  83.     this.eventManager_.listen(video, 'waiting', () => this.onPollGapJump_());
  85.     /**
  86.      * We can't trust |readyState| or 'waiting' events on all platforms. To make
  87.      * up for this, we poll the current time. If we think we are in a gap, jump
  88.      * out of it.
  89.      *
  90.      * See: https://bit.ly/2McuXxm and https://bit.ly/2K5xmJO
  91.      *
  92.      * @private {?shaka.util.Timer}
  93.      */
  94.     this.gapJumpTimer_ = new shaka.util.Timer(() => {
  95.       this.onPollGapJump_();
  96.     });
  97.   }
  100.   /** @override */
  101.   release() {
  102.     if (this.eventManager_) {
  103.       this.eventManager_.release();
  104.       this.eventManager_ = null;
  105.     }
  107.     if (this.gapJumpTimer_ != null) {
  108.       this.gapJumpTimer_.stop();
  109.       this.gapJumpTimer_ = null;
  110.     }
  112.     if (this.stallDetector_) {
  113.       this.stallDetector_.release();
  114.       this.stallDetector_ = null;
  115.     }
  117.     this.onEvent_ = null;
  118.     this.timeline_ = null;
  119.     this.video_ = null;
  120.   }
  123.   /**
  124.    * Called when a segment is appended by StreamingEngine, but not when a clear
  125.    * is pending. This means StreamingEngine will continue buffering forward from
  126.    * what is buffered.  So we know about any gaps before the start.
  127.    */
  128.   onSegmentAppended() {
  129.     this.hadSegmentAppended_ = true;
  130.     this.onPollGapJump_();
  131.   }
  133.   /**
  134.    * Called when playback has started and the video element is
  135.    * listening for seeks.
  136.    *
  137.    * @param {number} startTime
  138.    */
  139.   onStarted(startTime) {
  140.     this.started_ = true;
  141.     if (this.video_.seeking && !this.seekingEventReceived_) {
  142.       this.seekingEventReceived_ = true;
  143.       this.startTime_ = startTime;
  144.     }
  145.     if (this.gapJumpTimer_) {
  146.       this.gapJumpTimer_.tickEvery(this.config_.gapJumpTimerTime);
  147.     }
  148.     this.onPollGapJump_();
  149.   }
  151.   /** Called when a seek has started. */
  152.   onSeeking() {
  153.     this.seekingEventReceived_ = true;
  154.     this.hadSegmentAppended_ = false;
  155.     this.onPollGapJump_();
  156.   }
  159.   /**
  160.    * Returns the total number of playback gaps jumped.
  161.    * @return {number}
  162.    */
  163.   getGapsJumped() {
  164.     return this.gapsJumped_;
  165.   }
  168.   /**
  169.    * Called on a recurring timer to check for gaps in the media.  This is also
  170.    * called in a 'waiting' event.
  171.    *
  172.    * @private
  173.    */
  174.   onPollGapJump_() {
  175.     // Don't gap jump before the video is ready to play.
  176.     if (this.video_.readyState == 0) {
  177.       return;
  178.     }
  179.     // Don't gap jump before playback started
  180.     if (!this.started_) {
  181.       return;
  182.     }
  183.     // Do not gap jump if seeking has begun, but the seeking event has not
  184.     // yet fired for this particular seek.
  185.     if (this.video_.seeking) {
  186.       if (!this.seekingEventReceived_) {
  187.         return;
  188.       }
  189.     } else {
  190.       this.seekingEventReceived_ = false;
  191.     }
  192.     // Don't gap jump while paused, so that you don't constantly jump ahead
  193.     // while paused on a livestream.  We make an exception for time 0, since we
  194.     // may be _required_ to seek on startup before play can begin, but only if
  195.     // autoplay is enabled.
  196.     if (this.video_.paused && (this.video_.currentTime != this.startTime_ ||
  197.       (!this.video_.autoplay && this.video_.currentTime == this.startTime_))) {
  198.       return;
  199.     }
  202.     // When the ready state changes, we have moved on, so we should fire the
  203.     // large gap event if we see one.
  204.     if (this.video_.readyState != this.prevReadyState_) {
  205.       this.prevReadyState_ = this.video_.readyState;
  206.     }
  208.     if (this.stallDetector_ && this.stallDetector_.poll()) {
  209.       // Some action was taken by StallDetector, so don't do anything yet.
  210.       return;
  211.     }
  214.     const currentTime = this.video_.currentTime;
  215.     const buffered = this.video_.buffered;
  216.     const gapDetectionThreshold = this.config_.gapDetectionThreshold;
  218.     const gapIndex = shaka.media.TimeRangesUtils.getGapIndex(
  219.         buffered, currentTime, gapDetectionThreshold);
  221.     // The current time is unbuffered or is too far from a gap.
  222.     if (gapIndex == null) {
  223.       return;
  224.     }
  226.     // If we are before the first buffered range, this could be an unbuffered
  227.     // seek.  So wait until a segment is appended so we are sure it is a gap.
  228.     if (gapIndex == 0 && !this.hadSegmentAppended_) {
  229.       return;
  230.     }
  232.     // StreamingEngine can buffer past the seek end, but still don't allow
  233.     // seeking past it.
  234.     let jumpTo = buffered.start(gapIndex);
  235.     // Workaround for Xbox with Legacy Edge. On this platform video element
  236.     // often rounds value we want to set as currentTime and we are not able
  237.     // to jump over the gap.
  238.     if (shaka.util.Platform.isLegacyEdge() ||
  239.         shaka.util.Platform.isXboxOne() ||
  240.         shaka.util.Platform.isTizen()) {
  241.       const gapPadding = this.config_.gapPadding;
  242.       jumpTo = Math.ceil((jumpTo + gapPadding) * 100) / 100;
  243.     }
  244.     const seekEnd = this.timeline_.getSeekRangeEnd();
  245.     if (jumpTo >= seekEnd) {
  246.       return;
  247.     }
  249.     const jumpSize = jumpTo - currentTime;
  251.     // If we jump to exactly the gap start, we may detect a small gap due to
  252.     // rounding errors or browser bugs.  We can ignore these extremely small
  253.     // gaps since the browser should play through them for us.
  254.     if (jumpSize < shaka.media.GapJumpingController.BROWSER_GAP_TOLERANCE) {
  255.       return;
  256.     }
  258.     if (gapIndex == 0) {
  259.       shaka.log.info(
  260.           'Jumping forward', jumpSize,
  261.           'seconds because of gap before start time of', jumpTo);
  262.     } else {
  263.       shaka.log.info(
  264.           'Jumping forward', jumpSize, 'seconds because of gap starting at',
  265.           buffered.end(gapIndex - 1), 'and ending at', jumpTo);
  266.     }
  268.     this.video_.currentTime = jumpTo;
  269.     // This accounts for the possibility that we jump a gap at the start
  270.     // position but we jump _into_ another gap. By setting the start
  271.     // position to the new jumpTo we ensure that the check above will
  272.     // pass even though the video is still paused.
  273.     if (currentTime == this.startTime_) {
  274.       this.startTime_ = jumpTo;
  275.     }
  276.     this.gapsJumped_++;
  277.     this.onEvent_(
  278.         new shaka.util.FakeEvent(shaka.util.FakeEvent.EventName.GapJumped));
  279.   }
  280. };
  283. /**
  284.  * The limit, in seconds, for the gap size that we will assume the browser will
  285.  * handle for us.
  286.  * @const
  287.  */
  288. shaka.media.GapJumpingController.BROWSER_GAP_TOLERANCE = 0.001;