Source: lib/media/gap_jumping_controller.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.media.GapJumpingController');
  20. goog.require('shaka.log');
  21. goog.require('shaka.media.TimeRangesUtils');
  22. goog.require('shaka.util.EventManager');
  23. goog.require('shaka.util.FakeEvent');
  24. goog.require('shaka.util.IDestroyable');
  25. goog.require('shaka.util.Timer');
  29. /**
  30.  * Creates a new GapJumpingController that handles jumping gaps that appear
  31.  * within the content.  This will only jump gaps between two buffered ranges,
  32.  * so we should not have to worry about the availability window.
  33.  *
  34.  * @param {!HTMLMediaElement} video
  35.  * @param {shakaExtern.Manifest} manifest
  36.  * @param {shakaExtern.StreamingConfiguration} config
  37.  * @param {function(!Event)} onEvent Called when an event is raised to be sent
  38.  *   to the application.
  39.  *
  40.  * @constructor
  41.  * @struct
  42.  * @implements {shaka.util.IDestroyable}
  43.  */
  44. shaka.media.GapJumpingController = function(video, manifest, config, onEvent) {
  45.   /** @private {HTMLMediaElement} */
  46.   this.video_ = video;
  48.   /** @private {?shakaExtern.Manifest} */
  49.   this.manifest_ = manifest;
  51.   /** @private {?shakaExtern.StreamingConfiguration} */
  52.   this.config_ = config;
  54.   /** @private {?function(!Event)} */
  55.   this.onEvent_ = onEvent;
  57.   /** @private {shaka.util.EventManager} */
  58.   this.eventManager_ = new shaka.util.EventManager();
  60.   /** @private {?shaka.util.Timer} */
  61.   this.gapJumpTimer_ = null;
  63.   /** @private {boolean} */
  64.   this.seekingEventReceived_ = false;
  66.   /** @private {number} */
  67.   this.prevReadyState_ = video.readyState;
  69.   /** @private {boolean} */
  70.   this.didFireLargeGap_ = false;
  72.   /**
  73.    * The wall-clock time (in milliseconds) that the stall occurred.  This is
  74.    * used to ensure we don't flush the pipeline too often.
  75.    * @private {number}
  76.    */
  77.   this.stallWallTime_ = -1;
  79.   /**
  80.    * The playhead time where we think a stall occurred.  When the ready state
  81.    * says we don't have enough data and the playhead stops too long, we assume
  82.    * we have stalled.
  83.    * @private {number}
  84.    */
  85.   this.stallPlayheadTime_ = -1;
  87.   /**
  88.    * True if we have already flushed the pipeline at stallPlayheadTime_.
  89.    * Allows us to avoid flushing multiple times for the same stall.
  90.    * @private {boolean}
  91.    */
  92.   this.stallCorrected_ = false;
  94.   /** @private {boolean} */
  95.   this.hadSegmentAppended_ = false;
  98.   let pollGap = this.onPollGapJump_.bind(this);
  99.   this.eventManager_.listen(video, 'waiting', pollGap);
  101.   // We can't trust readyState or 'waiting' events on all platforms.  So poll
  102.   // the current time and if we are in a gap, jump it.
  103.   // See: https://goo.gl/sbSHp9 and https://goo.gl/cuAcYd
  104.   this.gapJumpTimer_ = new shaka.util.Timer(pollGap);
  105.   this.gapJumpTimer_.scheduleRepeated(0.25);
  106. };
  109. /**
  110.  * The limit, in seconds, for the gap size that we will assume the browser will
  111.  * handle for us.
  112.  * @const
  113.  */
  114. shaka.media.GapJumpingController.BROWSER_GAP_TOLERANCE = 0.001;
  117. /** @override */
  118. shaka.media.GapJumpingController.prototype.destroy = function() {
  119.   let p = this.eventManager_.destroy();
  120.   this.eventManager_ = null;
  121.   this.video_ = null;
  122.   this.manifest_ = null;
  123.   this.onEvent_ = null;
  125.   if (this.gapJumpTimer_ != null) {
  126.     this.gapJumpTimer_.cancel();
  127.     this.gapJumpTimer_ = null;
  128.   }
  130.   return p;
  131. };
  134. /**
  135.  * Called when a segment is appended by StreamingEngine, but not when a clear is
  136.  * pending.  This means StreamingEngine will continue buffering forward from
  137.  * what is buffered.  So we know about any gaps before the start.
  138.  */
  139. shaka.media.GapJumpingController.prototype.onSegmentAppended = function() {
  140.   this.hadSegmentAppended_ = true;
  141.   this.onPollGapJump_();
  142. };
  145. /** Called when a seek has started. */
  146. shaka.media.GapJumpingController.prototype.onSeeking = function() {
  147.   this.seekingEventReceived_ = true;
  148.   this.hadSegmentAppended_ = false;
  149.   this.didFireLargeGap_ = false;
  150. };
  153. /**
  154.  * Called on a recurring timer to check for gaps in the media.  This is also
  155.  * called in a 'waiting' event.
  156.  *
  157.  * @private
  158.  */
  159. shaka.media.GapJumpingController.prototype.onPollGapJump_ = function() {
  160.   // Don't gap jump before the video is ready to play.
  161.   if (this.video_.readyState == 0) return;
  162.   // Do not gap jump if seeking has begun, but the seeking event has not
  163.   // yet fired for this particular seek.
  164.   if (this.video_.seeking) {
  165.     if (!this.seekingEventReceived_) {
  166.       return;
  167.     }
  168.   } else {
  169.     this.seekingEventReceived_ = false;
  170.   }
  171.   // Don't gap jump while paused, so that you don't constantly jump ahead while
  172.   // paused on a livestream.
  173.   if (this.video_.paused) return;
  176.   // When the ready state changes, we have moved on, so we should fire the large
  177.   // gap event if we see one.
  178.   if (this.video_.readyState != this.prevReadyState_) {
  179.     this.didFireLargeGap_ = false;
  180.     this.prevReadyState_ = this.video_.readyState;
  181.   }
  183.   const smallGapLimit = this.config_.smallGapLimit;
  184.   let currentTime = this.video_.currentTime;
  185.   let buffered = this.video_.buffered;
  187.   let gapIndex = shaka.media.TimeRangesUtils.getGapIndex(buffered, currentTime);
  189.   // The current time is unbuffered or is too far from a gap.
  190.   if (gapIndex == null) {
  191.     this.handleStall_();
  192.     return;
  193.   }
  194.   // If we are before the first buffered range, this could be an unbuffered
  195.   // seek.  So wait until a segment is appended so we are sure it is a gap.
  196.   if (gapIndex == 0 && !this.hadSegmentAppended_) {
  197.     return;
  198.   }
  200.   // StreamingEngine can buffer past the seek end, but still don't allow seeking
  201.   // past it.
  202.   let jumpTo = buffered.start(gapIndex);
  203.   let seekEnd = this.manifest_.presentationTimeline.getSeekRangeEnd();
  204.   if (jumpTo >= seekEnd) {
  205.     return;
  206.   }
  208.   let jumpSize = jumpTo - currentTime;
  209.   let isGapSmall = jumpSize <= smallGapLimit;
  210.   let jumpLargeGap = false;
  212.   // If we jump to exactly the gap start, we may detect a small gap due to
  213.   // rounding errors or browser bugs.  We can ignore these extremely small gaps
  214.   // since the browser should play through them for us.
  215.   if (jumpSize < shaka.media.GapJumpingController.BROWSER_GAP_TOLERANCE) {
  216.     return;
  217.   }
  219.   if (!isGapSmall && !this.didFireLargeGap_) {
  220.     this.didFireLargeGap_ = true;
  222.     // Event firing is synchronous.
  223.     let event = new shaka.util.FakeEvent(
  224.         'largegap', {'currentTime': currentTime, 'gapSize': jumpSize});
  225.     event.cancelable = true;
  226.     this.onEvent_(event);
  228.     if (this.config_.jumpLargeGaps && !event.defaultPrevented) {
  229.       jumpLargeGap = true;
  230.     } else {
  231.       shaka.log.info('Ignoring large gap at', currentTime, 'size', jumpSize);
  232.     }
  233.   }
  235.   if (isGapSmall || jumpLargeGap) {
  236.     if (gapIndex == 0) {
  237.       shaka.log.info(
  238.           'Jumping forward', jumpSize,
  239.           'seconds because of gap before start time of', jumpTo);
  240.     } else {
  241.       shaka.log.info(
  242.           'Jumping forward', jumpSize, 'seconds because of gap starting at',
  243.           buffered.end(gapIndex - 1), 'and ending at', jumpTo);
  244.     }
  246.     this.video_.currentTime = jumpTo;
  247.   }
  248. };
  251. /**
  252.  * This determines if we are stalled inside a buffered range and corrects it if
  253.  * possible.
  254.  * @private
  255.  */
  256. shaka.media.GapJumpingController.prototype.handleStall_ = function() {
  257.   let currentTime = this.video_.currentTime;
  258.   let buffered = this.video_.buffered;
  260.   if (!this.video_.paused && this.video_.playbackRate > 0) {
  261.     // Some platforms/browsers can get stuck in the middle of a buffered range
  262.     // (e.g. when seeking in a background tab).  Flush the media pipeline to
  263.     // help. Flush once we have stopped for more than 1 second inside a buffered
  264.     // range.
  265.     if (this.stallPlayheadTime_ != currentTime) {
  266.       this.stallPlayheadTime_ = currentTime;
  267.       this.stallWallTime_ = Date.now();
  268.       this.stallCorrected_ = false;
  269.     } else if (!this.stallCorrected_ &&
  270.                this.stallWallTime_ < Date.now() - 1000) {
  271.       for (let i = 0; i < buffered.length; i++) {
  272.         // Ignore the end of the buffered range since it may not play any more
  273.         // on all platforms.
  274.         if (currentTime >= buffered.start(i) &&
  275.             currentTime < buffered.end(i) - 0.5) {
  276.           shaka.log.debug(
  277.               'Flushing media pipeline due to stall inside buffered range');
  278.           this.video_.currentTime += 0.1;
  279.           this.stallPlayheadTime_ = this.video_.currentTime;
  280.           this.stallCorrected_ = true;
  281.           break;
  282.         }
  283.       }
  284.     }
  285.   }
  286. };