Source: lib/media/video_wrapper.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.VideoWrapper');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.util.EventManager');
  23. goog.require('shaka.util.IDestroyable');
  24. goog.require('shaka.util.Timer');
  28. /**
  29.  * Creates a new VideoWrapper that manages setting current time and playback
  30.  * rate.  This handles seeks before content is loaded and ensuring the video
  31.  * time is set properly.  This doesn't handle repositioning within the
  32.  * presentation window.
  33.  *
  34.  * @param {!HTMLMediaElement} video
  35.  * @param {function()} onSeek Called when the video seeks.
  36.  * @param {number} startTime The time to start at.
  37.  *
  38.  * @constructor
  39.  * @struct
  40.  * @implements {shaka.util.IDestroyable}
  41.  */
  42. shaka.media.VideoWrapper = function(video, onSeek, startTime) {
  43.   /** @private {HTMLMediaElement} */
  44.   this.video_ = video;
  46.   /** @private {?function()} */
  47.   this.onSeek_ = onSeek;
  49.   /** @private {number} */
  50.   this.startTime_ = startTime;
  52.   /** @private {shaka.util.EventManager} */
  53.   this.eventManager_ = new shaka.util.EventManager();
  55.   /** @private {number} */
  56.   this.playbackRate_ = 1;
  58.   /** @private {boolean} */
  59.   this.buffering_ = false;
  61.   /** @private {shaka.util.Timer} */
  62.   this.trickPlayTimer_ = null;
  64.   // Check if the video has already loaded some metadata.
  65.   if (video.readyState > 0) {
  66.     this.onLoadedMetadata_();
  67.   } else {
  68.     this.eventManager_.listenOnce(
  69.         video, 'loadedmetadata', this.onLoadedMetadata_.bind(this));
  70.   }
  72.   this.eventManager_.listen(video, 'ratechange', this.onRateChange_.bind(this));
  73. };
  76. /** @override */
  77. shaka.media.VideoWrapper.prototype.destroy = function() {
  78.   let p = this.eventManager_.destroy();
  79.   this.eventManager_ = null;
  81.   if (this.trickPlayTimer_ != null) {
  82.     this.trickPlayTimer_.cancel();
  83.     this.trickPlayTimer_ = null;
  84.   }
  86.   this.video_ = null;
  87.   this.onSeek_ = null;
  89.   return p;
  90. };
  93. /**
  94.  * Gets the video's current (logical) position.
  95.  *
  96.  * @return {number}
  97.  */
  98. shaka.media.VideoWrapper.prototype.getTime = function() {
  99.   if (this.video_.readyState > 0) {
  100.     return this.video_.currentTime;
  101.   } else {
  102.     return this.startTime_;
  103.   }
  104. };
  107. /**
  108.  * Sets the current time of the video.
  109.  *
  110.  * @param {number} time
  111.  */
  112. shaka.media.VideoWrapper.prototype.setTime = function(time) {
  113.   if (this.video_.readyState > 0) {
  114.     this.movePlayhead_(this.video_.currentTime, time);
  115.   } else {
  116.     this.startTime_ = time;
  117.     setTimeout(this.onSeek_, 0);
  118.   }
  119. };
  122. /**
  123.  * Gets the current effective playback rate.  This may be negative even if the
  124.  * browser does not directly support rewinding.
  125.  * @return {number}
  126.  */
  127. shaka.media.VideoWrapper.prototype.getPlaybackRate = function() {
  128.   return this.playbackRate_;
  129. };
  132. /**
  133.  * Sets the playback rate.
  134.  * @param {number} rate
  135.  */
  136. shaka.media.VideoWrapper.prototype.setPlaybackRate = function(rate) {
  137.   if (this.trickPlayTimer_ != null) {
  138.     this.trickPlayTimer_.cancel();
  139.     this.trickPlayTimer_ = null;
  140.   }
  142.   this.playbackRate_ = rate;
  143.   // All major browsers support playback rates above zero.  Only need fake
  144.   // trick play for negative rates.
  145.   this.video_.playbackRate = (this.buffering_ || rate < 0) ? 0 : rate;
  147.   if (!this.buffering_ && rate < 0) {
  148.     // Defer creating the timer until we stop buffering.  This function will be
  149.     // called again from setBuffering().
  150.     let trickPlay = () => { this.video_.currentTime += rate / 4; };
  151.     this.trickPlayTimer_ = new shaka.util.Timer(trickPlay);
  152.     this.trickPlayTimer_.scheduleRepeated(0.25);
  153.   }
  154. };
  157. /**
  158.  * Stops the playhead for buffering, or resumes the playhead after buffering.
  159.  *
  160.  * @param {boolean} buffering True to stop the playhead; false to allow it to
  161.  *   continue.
  162.  */
  163. shaka.media.VideoWrapper.prototype.setBuffering = function(buffering) {
  164.   if (buffering != this.buffering_) {
  165.     this.buffering_ = buffering;
  166.     this.setPlaybackRate(this.playbackRate_);
  167.   }
  168. };
  171. /**
  172.  * Handles a 'ratechange' event.
  173.  *
  174.  * @private
  175.  */
  176. shaka.media.VideoWrapper.prototype.onRateChange_ = function() {
  177.   // NOTE: This will not allow explicitly setting the playback rate to 0 while
  178.   // the playback rate is negative.  Pause will still work.
  179.   let expectedRate =
  180.       this.buffering_ || this.playbackRate_ < 0 ? 0 : this.playbackRate_;
  182.   // Native controls in Edge trigger a change to playbackRate and set it to 0
  183.   // when seeking.  If we don't exclude 0 from this check, we will force the
  184.   // rate to stay at 0 after a seek with Edge native controls.
  185.   // https://github.com/google/shaka-player/issues/951
  186.   if (this.video_.playbackRate && this.video_.playbackRate != expectedRate) {
  187.     shaka.log.debug('Video playback rate changed to', this.video_.playbackRate);
  188.     this.setPlaybackRate(this.video_.playbackRate);
  189.   }
  190. };
  193. /**
  194.  * Handles a 'loadedmetadata' event.
  195.  *
  196.  * @private
  197.  */
  198. shaka.media.VideoWrapper.prototype.onLoadedMetadata_ = function() {
  199.   if (Math.abs(this.video_.currentTime - this.startTime_) < 0.001) {
  200.     this.onSeekingToStartTime_();
  201.   } else {
  202.     this.eventManager_.listenOnce(
  203.         this.video_, 'seeking', this.onSeekingToStartTime_.bind(this));
  204.     // If the currentTime != 0, it indicates that the user has seeked after
  205.     // calling load(), so it is intended to start from a specific timestamp
  206.     // when playback, and should not be overriden by the startTime.
  207.     if (this.video_.currentTime == 0) {
  208.       this.video_.currentTime = this.startTime_;
  209.     } else {
  210.       // This is a workaround solution. If the currentTime is not set again, the
  211.       // video is stuck and could not be played.
  212.       // TODO: Need further investigation why it happens. Before and after
  213.       // setting the current time, video.readyState is 1, video.paused is true,
  214.       // and video.buffered's TimeRanges length is 0.
  215.       // See: https://github.com/google/shaka-player/issues/1298
  216.       this.video_.currentTime = this.video_.currentTime;
  217.     }
  218.   }
  219. };
  222. /**
  223.  * Handles the 'seeking' event from the initial jump to the start time (if
  224.  * there is one).
  225.  *
  226.  * @private
  227.  */
  228. shaka.media.VideoWrapper.prototype.onSeekingToStartTime_ = function() {
  229.   goog.asserts.assert(this.video_.readyState > 0,
  230.                       'readyState should be greater than 0');
  231.   this.eventManager_.listen(this.video_, 'seeking', () => this.onSeek_());
  232. };
  235. /**
  236.  * Moves the playhead to the target time, triggering a call to onSeeking_().
  237.  *
  238.  * @param {number} currentTime
  239.  * @param {number} targetTime
  240.  * @private
  241.  */
  242. shaka.media.VideoWrapper.prototype.movePlayhead_ = function(
  243.     currentTime, targetTime) {
  244.   shaka.log.debug('Moving playhead...',
  245.                   'currentTime=' + currentTime,
  246.                   'targetTime=' + targetTime);
  247.   this.video_.currentTime = targetTime;
  249.   // Sometimes, IE and Edge ignore re-seeks.  Check every 100ms and try
  250.   // again if need be, up to 10 tries.
  251.   // Delay stats over 100 runs of a re-seeking integration test:
  252.   // IE     -   0ms -  47%
  253.   // IE     - 100ms -  63%
  254.   // Edge   -   0ms -   2%
  255.   // Edge   - 100ms -  40%
  256.   // Edge   - 200ms -  32%
  257.   // Edge   - 300ms -  24%
  258.   // Edge   - 400ms -   2%
  259.   // Chrome -   0ms - 100%
  260.   // TODO: File a bug on IE/Edge about this.
  261.   let tries = 0;
  262.   let recheck = () => {
  263.     if (!this.video_) return;
  264.     if (tries++ >= 10) return;
  266.     if (this.video_.currentTime == currentTime) {
  267.       // Sigh.  Try again.
  268.       this.video_.currentTime = targetTime;
  269.       setTimeout(recheck, 100);
  270.     }
  271.   };
  272.   setTimeout(recheck, 100);
  273. };