Source: lib/media/play_rate_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.PlayRateController');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.util.IReleasable');
  12. goog.require('shaka.util.Timer');
  14. /**
  15.  * The play rate controller controls the playback rate on the media element.
  16.  * This provides some missing functionality (e.g. negative playback rate). If
  17.  * the playback rate on the media element can change outside of the controller,
  18.  * the playback controller will need to be updated to stay in-sync.
  19.  *
  20.  * @implements {shaka.util.IReleasable}
  21.  * @final
  22.  */
  23. shaka.media.PlayRateController = class {
  24.   /**
  25.    * @param {shaka.media.PlayRateController.Harness} harness
  26.    */
  27.   constructor(harness) {
  28.     /** @private {?shaka.media.PlayRateController.Harness} */
  29.     this.harness_ = harness;
  31.     /** @private {boolean} */
  32.     this.isBuffering_ = false;
  34.     /** @private {number} */
  35.     this.rate_ = this.harness_.getRate();
  37.     /** @private {number} */
  38.     this.pollRate_ = 0.25;
  40.     /** @private {shaka.util.Timer} */
  41.     this.timer_ = new shaka.util.Timer(() => {
  42.       this.harness_.movePlayhead(this.rate_ * this.pollRate_);
  43.     });
  44.   }
  46.   /** @override */
  47.   release() {
  48.     this.set(this.getDefaultRate());
  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.    * Get the default play rate of the playback.
  92.    *
  93.    * @return {number}
  94.    */
  95.   getDefaultRate() {
  96.     return this.harness_.getDefaultRate();
  97.   }
  99.   /**
  100.    * Reapply the effects of |this.rate_| and |this.active_| to the media
  101.    * element. This will only update the rate via the harness if the desired rate
  102.    * has changed.
  103.    *
  104.    * @private
  105.    */
  106.   apply_() {
  107.     // Always stop the timer. We may not start it again.
  108.     this.timer_.stop();
  110.     /** @type {number} */
  111.     const rate = this.calculateCurrentRate_();
  113.     shaka.log.v1('Changing effective playback rate to', rate);
  115.     if (rate >= 0) {
  116.       try {
  117.         this.applyRate_(rate);
  118.         return;
  119.       } catch (e) {
  120.         // Fall through to the next clause.
  121.         //
  122.         // Fast forward is accomplished through setting video.playbackRate.
  123.         // If the play rate value is not supported by the browser (too big),
  124.         // the browsers will throw.
  125.         // Use this as a cue to fall back to fast forward through repeated
  126.         // seeking, which is what we do for rewind as well.
  127.       }
  128.     }
  130.     // When moving backwards or forwards in large steps,
  131.     // set the playback rate to 0 so that we can manually
  132.     // seek backwards with out fighting the playhead.
  133.     this.timer_.tickEvery(this.pollRate_);
  134.     this.applyRate_(0);
  135.   }
  137.   /**
  138.    * Calculate the rate that the controller wants the media element to have
  139.    * based on the current state of the controller.
  140.    *
  141.    * @return {number}
  142.    * @private
  143.    */
  144.   calculateCurrentRate_() {
  145.     return this.isBuffering_ ? 0 : this.rate_;
  146.   }
  148.   /**
  149.    * If the new rate is different than the media element's playback rate, this
  150.    * will change the playback rate. If the rate does not need to change, it will
  151.    * not be set. This will avoid unnecessary ratechange events.
  152.    *
  153.    * @param {number} newRate
  154.    * @return {boolean}
  155.    * @private
  156.    */
  157.   applyRate_(newRate) {
  158.     const oldRate = this.harness_.getRate();
  160.     if (oldRate != newRate) {
  161.       this.harness_.setRate(newRate);
  162.     }
  164.     return oldRate != newRate;
  165.   }
  166. };
  169. /**
  170.  * @typedef {{
  171.  *   getRate: function():number,
  172.  *   getDefaultRate: function():number,
  173.  *   setRate: function(number),
  174.  *   movePlayhead: function(number)
  175.  * }}
  176.  *
  177.  * @description
  178.  *   A layer of abstraction between the controller and what it is controlling.
  179.  *   In tests this will be implemented with spies. In production this will be
  180.  *   implemented using a media element.
  181.  *
  182.  * @property {function():number} getRate
  183.  *   Get the current playback rate being seen by the user.
  184.  *
  185.  * @property {function():number} getDefaultRate
  186.  *   Get the default playback rate that the user should see.
  187.  *
  188.  * @property {function(number)} setRate
  189.  *   Set the playback rate that the user should see.
  190.  *
  191.  * @property {function(number)} movePlayhead
  192.  *   Move the playhead N seconds. If N is positive, the playhead will move
  193.  *   forward abs(N) seconds. If N is negative, the playhead will move backwards
  194.  *   abs(N) seconds.
  195.  */
  196. shaka.media.PlayRateController.Harness;