Source: lib/media/play_rate_controller.js

  1. /** @license
  2.  * Copyright 2016 Google LLC
  3.  * SPDX-License-Identifier: Apache-2.0
  4.  */
  6. goog.provide('shaka.media.PlayRateController');
  8. goog.require('goog.asserts');
  9. goog.require('shaka.log');
  10. goog.require('shaka.util.IReleasable');
  11. goog.require('shaka.util.Timer');
  13. /**
  14.  * The play rate controller controls the playback rate on the media element.
  15.  * This provides some missing functionality (e.g. negative playback rate). If
  16.  * the playback rate on the media element can change outside of the controller,
  17.  * the playback controller will need to be updated to stay in-sync.
  18.  *
  19.  * TODO: Try not to manage buffering above the browser with playbackRate=0.
  20.  *
  21.  * @implements {shaka.util.IReleasable}
  22.  * @final
  23.  */
  24. shaka.media.PlayRateController = class {
  25.   /**
  26.    * @param {shaka.media.PlayRateController.Harness} harness
  27.    */
  28.   constructor(harness) {
  29.     /** @private {?shaka.media.PlayRateController.Harness} */
  30.     this.harness_ = harness;
  32.     /** @private {boolean} */
  33.     this.isBuffering_ = false;
  35.     /** @private {number} */
  36.     this.rate_ = this.harness_.getRate();
  38.     /** @private {number} */
  39.     this.pollRate_ = 0.25;
  41.     /** @private {shaka.util.Timer} */
  42.     this.timer_ = new shaka.util.Timer(() => {
  43.       this.harness_.movePlayhead(this.rate_ * this.pollRate_);
  44.     });
  45.   }
  47.   /** @override */
  48.   release() {
  49.     if (this.timer_) {
  50.       this.timer_.stop();
  51.       this.timer_ = null;
  52.     }
  54.     this.harness_ = null;
  55.   }
  57.   /**
  58.    * Sets the buffering flag, which controls the effective playback rate.
  59.    *
  60.    * @param {boolean} isBuffering If true, forces playback rate to 0 internally.
  61.    */
  62.   setBuffering(isBuffering) {
  63.     this.isBuffering_ = isBuffering;
  64.     this.apply_();
  65.   }
  67.   /**
  68.    * Set the playback rate. This rate will only be used as provided when the
  69.    * player is not buffering. You should never set the rate to 0.
  70.    *
  71.    * @param {number} rate
  72.    */
  73.   set(rate) {
  74.     goog.asserts.assert(rate != 0, 'Should never set rate of 0 explicitly!');
  75.     this.rate_ = rate;
  76.     this.apply_();
  77.   }
  79.   /**
  80.    * Get the real rate of the playback. This means that if we are using trick
  81.    * play, this will report the trick play rate. If playback is occurring as
  82.    * normal, this will report 1.
  83.    *
  84.    * @return {number}
  85.    */
  86.   getRealRate() {
  87.     return this.rate_;
  88.   }
  90.   /**
  91.    * Reapply the effects of |this.rate_| and |this.active_| to the media
  92.    * element. This will only update the rate via the harness if the desired rate
  93.    * has changed.
  94.    *
  95.    * @private
  96.    */
  97.   apply_() {
  98.     // Always stop the timer. We may not start it again.
  99.     this.timer_.stop();
  101.     /** @type {number} */
  102.     const rate = this.calculateCurrentRate_();
  104.     shaka.log.v1('Changing effective playback rate to', rate);
  106.     if (rate >= 0) {
  107.       try {
  108.         this.applyRate_(rate);
  109.         return;
  110.       } catch (e) {
  111.         // Fall through to the next clause.
  112.         //
  113.         // Fast forward is accomplished through setting video.playbackRate.
  114.         // If the play rate value is not supported by the browser (too big),
  115.         // the browsers will throw.
  116.         // Use this as a cue to fall back to fast forward through repeated
  117.         // seeking, which is what we do for rewind as well.
  118.       }
  119.     }
  121.     // When moving backwards or forwards in large steps,
  122.     // set the playback rate to 0 so that we can manually
  123.     // seek backwards with out fighting the playhead.
  124.     this.timer_.tickEvery(this.pollRate_);
  125.     this.applyRate_(0);
  126.   }
  128.   /**
  129.    * Calculate the rate that the controller wants the media element to have
  130.    * based on the current state of the controller.
  131.    *
  132.    * @return {number}
  133.    * @private
  134.    */
  135.   calculateCurrentRate_() {
  136.     return this.isBuffering_ ? 0 : this.rate_;
  137.   }
  139.   /**
  140.    * If the new rate is different than the media element's playback rate, this
  141.    * will change the playback rate. If the rate does not need to change, it will
  142.    * not be set. This will avoid unnecessary ratechange events.
  143.    *
  144.    * @param {number} newRate
  145.    * @return {boolean}
  146.    * @private
  147.    */
  148.   applyRate_(newRate) {
  149.     const oldRate = this.harness_.getRate();
  151.     if (oldRate != newRate) {
  152.       this.harness_.setRate(newRate);
  153.     }
  155.     return oldRate != newRate;
  156.   }
  157. };
  160. /**
  161.  * @typedef {{
  162.  *   getRate: function():number,
  163.  *   setRate: function(number),
  164.  *   movePlayhead: function(number)
  165.  * }}
  166.  *
  167.  * @description
  168.  *   A layer of abstraction between the controller and what it is controlling.
  169.  *   In tests this will be implemented with spies. In production this will be
  170.  *   implemented using a media element.
  171.  *
  172.  * @property {function():number} getRate
  173.  *   Get the current playback rate being seen by the user.
  174.  *
  175.  * @property {function(number)} setRate
  176.  *   Set the playback rate that the user should see.
  177.  *
  178.  * @property {function(number)} movePlayhead
  179.  *   Move the playhead N seconds. If N is positive, the playhead will move
  180.  *   forward abs(N) seconds. If N is negative, the playhead will move backwards
  181.  *   abs(N) seconds.
  182.  */
  183. shaka.media.PlayRateController.Harness;