Source: lib/media/buffering_observer.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.BufferingObserver');
  10. /**
  11.  * The buffering observer watches how much content has been buffered and raises
  12.  * events when the state changes (enough => not enough or vice versa).
  13.  *
  14.  * @final
  15.  */
  16. shaka.media.BufferingObserver = class {
  17.   /**
  18.    * @param {number} thresholdWhenStarving
  19.    * @param {number} thresholdWhenSatisfied
  20.    */
  21.   constructor(thresholdWhenStarving, thresholdWhenSatisfied) {
  22.     const State = shaka.media.BufferingObserver.State;
  24.     /** @private {shaka.media.BufferingObserver.State} */
  25.     this.previousState_ = State.SATISFIED;
  27.     /** @private {!Map.<shaka.media.BufferingObserver.State, number>} */
  28.     this.thresholds_ = new Map()
  29.         .set(State.SATISFIED, thresholdWhenSatisfied)
  30.         .set(State.STARVING, thresholdWhenStarving);
  32.     /** @private {number} */
  33.     this.lastRebufferTime_ = 0;
  34.   }
  36.   /**
  37.    * @param {number} thresholdWhenStarving
  38.    * @param {number} thresholdWhenSatisfied
  39.    */
  40.   setThresholds(thresholdWhenStarving, thresholdWhenSatisfied) {
  41.     const State = shaka.media.BufferingObserver.State;
  42.     this.thresholds_
  43.         .set(State.SATISFIED, thresholdWhenSatisfied)
  44.         .set(State.STARVING, thresholdWhenStarving);
  45.   }
  47.   /**
  48.    * Update the observer by telling it how much content has been buffered (in
  49.    * seconds) and if we are buffered to the end of the presentation. If the
  50.    * controller believes the state has changed, it will return |true|.
  51.    *
  52.    * @param {number} bufferLead
  53.    * @param {boolean} bufferedToEnd
  54.    * @return {boolean}
  55.    */
  56.   update(bufferLead, bufferedToEnd) {
  57.     const State = shaka.media.BufferingObserver.State;
  59.     /**
  60.      * Our threshold for how much we need before we declare ourselves as
  61.      * starving is based on whether or not we were just starving. If we
  62.      * were just starving, we are more likely to starve again, so we require
  63.      * more content to be buffered than if we were not just starving.
  64.      *
  65.      * @type {number}
  66.      */
  67.     const threshold = this.thresholds_.get(this.previousState_);
  69.     const oldState = this.previousState_;
  70.     const newState = (bufferedToEnd || bufferLead >= threshold) ?
  71.                      (State.SATISFIED) :
  72.                      (State.STARVING);
  74.     // Save the new state now so that calls to |getState| from any callbacks
  75.     // will be accurate.
  76.     this.previousState_ = newState;
  78.     // Return |true| only when the state has changed.
  79.     const stateChanged = oldState != newState;
  81.     if (stateChanged && newState === State.SATISFIED) {
  82.       this.lastRebufferTime_ = Date.now();
  83.     }
  85.     return stateChanged;
  86.   }
  88.   /**
  89.    * Set which state that the observer should think playback was in.
  90.    *
  91.    * @param {shaka.media.BufferingObserver.State} state
  92.    */
  93.   setState(state) {
  94.     this.previousState_ = state;
  95.   }
  97.   /**
  98.    * Get the state that the observer last thought playback was in.
  99.    *
  100.    * @return {shaka.media.BufferingObserver.State}
  101.    */
  102.   getState() {
  103.     return this.previousState_;
  104.   }
  106.   /**
  107.    * Return the last time that the state went from |STARVING| to |SATISFIED|.
  108.    * @return {number}
  109.    */
  110.   getLastRebufferTime() {
  111.     return this.lastRebufferTime_;
  112.   }
  114.   /**
  115.    * Reset the last rebuffer time to zero.
  116.    */
  117.   resetLastRebufferTime() {
  118.     this.lastRebufferTime_ = 0;
  119.   }
  120. };
  122. /**
  123.  * Rather than using booleans to communicate what state we are in, we have this
  124.  * enum.
  125.  *
  126.  * @enum {number}
  127.  */
  128. shaka.media.BufferingObserver.State = {
  129.   STARVING: 0,
  130.   SATISFIED: 1,
  131. };