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);
  31.   }
  33.   /**
  34.    * @param {number} thresholdWhenStarving
  35.    * @param {number} thresholdWhenSatisfied
  36.    */
  37.   setThresholds(thresholdWhenStarving, thresholdWhenSatisfied) {
  38.     const State = shaka.media.BufferingObserver.State;
  39.     this.thresholds_
  40.         .set(State.SATISFIED, thresholdWhenSatisfied)
  41.         .set(State.STARVING, thresholdWhenStarving);
  42.   }
  44.   /**
  45.    * Update the observer by telling it how much content has been buffered (in
  46.    * seconds) and if we are buffered to the end of the presentation. If the
  47.    * controller believes the state has changed, it will return |true|.
  48.    *
  49.    * @param {number} bufferLead
  50.    * @param {boolean} bufferedToEnd
  51.    * @return {boolean}
  52.    */
  53.   update(bufferLead, bufferedToEnd) {
  54.     const State = shaka.media.BufferingObserver.State;
  56.     /**
  57.      * Our threshold for how much we need before we declare ourselves as
  58.      * starving is based on whether or not we were just starving. If we
  59.      * were just starving, we are more likely to starve again, so we require
  60.      * more content to be buffered than if we were not just starving.
  61.      *
  62.      * @type {number}
  63.      */
  64.     const threshold = this.thresholds_.get(this.previousState_);
  66.     const oldState = this.previousState_;
  67.     const newState = (bufferedToEnd || bufferLead >= threshold) ?
  68.                      (State.SATISFIED) :
  69.                      (State.STARVING);
  71.     // Save the new state now so that calls to |getState| from any callbacks
  72.     // will be accurate.
  73.     this.previousState_ = newState;
  75.     // Return |true| only when the state has changed.
  76.     return oldState != newState;
  77.   }
  79.   /**
  80.    * Set which state that the observer should think playback was in.
  81.    *
  82.    * @param {shaka.media.BufferingObserver.State} state
  83.    */
  84.   setState(state) {
  85.     this.previousState_ = state;
  86.   }
  88.   /**
  89.    * Get the state that the observer last thought playback was in.
  90.    *
  91.    * @return {shaka.media.BufferingObserver.State}
  92.    */
  93.   getState() {
  94.     return this.previousState_;
  95.   }
  96. };
  98. /**
  99.  * Rather than using booleans to communicate what state we are in, we have this
  100.  * enum.
  101.  *
  102.  * @enum {number}
  103.  */
  104. shaka.media.BufferingObserver.State = {
  105.   STARVING: 0,
  106.   SATISFIED: 1,
  107. };