Source: lib/abr/simple_abr_manager.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.abr.SimpleAbrManager');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.abr.EwmaBandwidthEstimator');
  22. goog.require('shaka.log');
  23. goog.require('shaka.util.StreamUtils');
  27. /**
  28.  * <p>
  29.  * This defines the default ABR manager for the Player.  An instance of this
  30.  * class is used when no ABR manager is given.
  31.  * </p>
  32.  * <p>
  33.  * The behavior of this class is to take throughput samples using
  34.  * segmentDownloaded to estimate the current network bandwidth.  Then it will
  35.  * use that to choose the streams that best fit the current bandwidth.  It will
  36.  * always pick the highest bandwidth variant it thinks can be played.
  37.  * </p>
  38.  * <p>
  39.  * After initial choices are made, this class will call switchCallback() when
  40.  * there is a better choice.  switchCallback() will not be called more than once
  41.  * per ({@link shaka.abr.SimpleAbrManager.SWITCH_INTERVAL_MS}).
  42.  * </p>
  43.  *
  44.  * @constructor
  45.  * @struct
  46.  * @implements {shakaExtern.AbrManager}
  47.  * @export
  48.  */
  49. shaka.abr.SimpleAbrManager = function() {
  50.   /** @private {?shakaExtern.AbrManager.SwitchCallback} */
  51.   this.switch_ = null;
  53.   /** @private {boolean} */
  54.   this.enabled_ = false;
  56.   /** @private {shaka.abr.EwmaBandwidthEstimator} */
  57.   this.bandwidthEstimator_ = new shaka.abr.EwmaBandwidthEstimator();
  58.   // TODO: Consider using NetworkInformation's change event to throw out an old
  59.   // estimate based on changing network types, such as wifi => 3g.
  61.   /**
  62.    * A filtered list of Variants to choose from.
  63.    * @private {!Array.<!shakaExtern.Variant>}
  64.    */
  65.   this.variants_ = [];
  67.   /** @private {boolean} */
  68.   this.startupComplete_ = false;
  70.   /**
  71.    * The last wall-clock time, in milliseconds, when streams were chosen.
  72.    *
  73.    * @private {?number}
  74.    */
  75.   this.lastTimeChosenMs_ = null;
  77.   /** @private {?shakaExtern.AbrConfiguration} */
  78.   this.config_ = null;
  79. };
  82. /**
  83.  * @override
  84.  * @export
  85.  */
  86. shaka.abr.SimpleAbrManager.prototype.stop = function() {
  87.   this.switch_ = null;
  88.   this.enabled_ = false;
  89.   this.variants_ = [];
  90.   this.lastTimeChosenMs_ = null;
  92.   // Don't reset |startupComplete_|: if we've left the startup interval, we can
  93.   // start using bandwidth estimates right away after init() is called.
  94. };
  97. /**
  98.  * @override
  99.  * @export
  100.  */
  101. shaka.abr.SimpleAbrManager.prototype.init = function(switchCallback) {
  102.   this.switch_ = switchCallback;
  103. };
  106. /**
  107.  * @override
  108.  * @export
  109.  */
  110. shaka.abr.SimpleAbrManager.prototype.chooseVariant = function() {
  111.   const SimpleAbrManager = shaka.abr.SimpleAbrManager;
  113.   // Get sorted Variants.
  114.   let sortedVariants = SimpleAbrManager.filterAndSortVariants_(
  115.       this.config_.restrictions, this.variants_);
  116.   let currentBandwidth = this.bandwidthEstimator_.getBandwidthEstimate(
  117.       this.config_.defaultBandwidthEstimate);
  119.   if (this.variants_.length && !sortedVariants.length) {
  120.     // If we couldn't meet the ABR restrictions, we should still play something.
  121.     // These restrictions are not "hard" restrictions in the way that top-level
  122.     // or DRM-based restrictions are.  Sort the variants without restrictions
  123.     // and keep just the first (lowest-bandwidth) one.
  124.     shaka.log.warning('No variants met the ABR restrictions. ' +
  125.                       'Choosing a variant by lowest bandwidth.');
  126.     sortedVariants = SimpleAbrManager.filterAndSortVariants_(
  127.         /* restrictions */ null, this.variants_);
  128.     sortedVariants = [sortedVariants[0]];
  129.   }
  131.   // Start by assuming that we will use the first Stream.
  132.   let chosen = sortedVariants[0] || null;
  134.   for (let i = 0; i < sortedVariants.length; ++i) {
  135.     let variant = sortedVariants[i];
  136.     let nextVariant = sortedVariants[i + 1] || {bandwidth: Infinity};
  138.     let minBandwidth = variant.bandwidth /
  139.                        this.config_.bandwidthDowngradeTarget;
  140.     let maxBandwidth = nextVariant.bandwidth /
  141.                        this.config_.bandwidthUpgradeTarget;
  142.     shaka.log.v2('Bandwidth ranges:',
  143.                  (variant.bandwidth / 1e6).toFixed(3),
  144.                  (minBandwidth / 1e6).toFixed(3),
  145.                  (maxBandwidth / 1e6).toFixed(3));
  147.     if (currentBandwidth >= minBandwidth && currentBandwidth <= maxBandwidth) {
  148.       chosen = variant;
  149.     }
  150.   }
  152.   this.lastTimeChosenMs_ = Date.now();
  153.   return chosen;
  154. };
  157. /**
  158.  * @override
  159.  * @export
  160.  */
  161. shaka.abr.SimpleAbrManager.prototype.enable = function() {
  162.   this.enabled_ = true;
  163. };
  166. /**
  167.  * @override
  168.  * @export
  169.  */
  170. shaka.abr.SimpleAbrManager.prototype.disable = function() {
  171.   this.enabled_ = false;
  172. };
  175. /**
  176.  * @override
  177.  * @export
  178.  */
  179. shaka.abr.SimpleAbrManager.prototype.segmentDownloaded = function(
  180.     deltaTimeMs, numBytes) {
  181.   shaka.log.v2('Segment downloaded:',
  182.                'deltaTimeMs=' + deltaTimeMs,
  183.                'numBytes=' + numBytes,
  184.                'lastTimeChosenMs=' + this.lastTimeChosenMs_,
  185.                'enabled=' + this.enabled_);
  186.   goog.asserts.assert(deltaTimeMs >= 0, 'expected a non-negative duration');
  187.   this.bandwidthEstimator_.sample(deltaTimeMs, numBytes);
  189.   if ((this.lastTimeChosenMs_ != null) && this.enabled_) {
  190.     this.suggestStreams_();
  191.   }
  192. };
  195. /**
  196.  * @override
  197.  * @export
  198.  */
  199. shaka.abr.SimpleAbrManager.prototype.getBandwidthEstimate = function() {
  200.   return this.bandwidthEstimator_.getBandwidthEstimate(
  201.       this.config_.defaultBandwidthEstimate);
  202. };
  205. /**
  206.  * @override
  207.  * @export
  208.  */
  209. shaka.abr.SimpleAbrManager.prototype.setVariants = function(variants) {
  210.   this.variants_ = variants;
  211. };
  214. /**
  215.  * @override
  216.  * @export
  217.  */
  218. shaka.abr.SimpleAbrManager.prototype.configure = function(config) {
  219.   this.config_ = config;
  220. };
  223. /**
  224.  * Calls switch_() with the variant chosen by chooseVariant().
  225.  *
  226.  * @private
  227.  */
  228. shaka.abr.SimpleAbrManager.prototype.suggestStreams_ = function() {
  229.   shaka.log.v2('Suggesting Streams...');
  230.   goog.asserts.assert(this.lastTimeChosenMs_ != null,
  231.                       'lastTimeChosenMs_ should not be null');
  233.   if (!this.startupComplete_) {
  234.     // Check if we've got enough data yet.
  235.     if (!this.bandwidthEstimator_.hasGoodEstimate()) {
  236.       shaka.log.v2('Still waiting for a good estimate...');
  237.       return;
  238.     }
  239.     this.startupComplete_ = true;
  240.   } else {
  241.     // Check if we've left the switch interval.
  242.     let now = Date.now();
  243.     let delta = now - this.lastTimeChosenMs_;
  244.     if (delta < this.config_.switchInterval * 1000) {
  245.       shaka.log.v2('Still within switch interval...');
  246.       return;
  247.     }
  248.   }
  250.   let chosenVariant = this.chooseVariant();
  251.   let bandwidthEstimate = this.bandwidthEstimator_.getBandwidthEstimate(
  252.       this.config_.defaultBandwidthEstimate);
  253.   let currentBandwidthKbps = Math.round(bandwidthEstimate / 1000.0);
  255.   shaka.log.debug(
  256.       'Calling switch_(), bandwidth=' + currentBandwidthKbps + ' kbps');
  257.   // If any of these chosen streams are already chosen, Player will filter them
  258.   // out before passing the choices on to StreamingEngine.
  259.   this.switch_(chosenVariant);
  260. };
  263. /**
  264.  * @param {?shakaExtern.Restrictions} restrictions
  265.  * @param {!Array.<shakaExtern.Variant>} variants
  266.  * @return {!Array.<shakaExtern.Variant>} variants filtered according to
  267.  *   |restrictions| and sorted in ascending order of bandwidth.
  268.  * @private
  269.  */
  270. shaka.abr.SimpleAbrManager.filterAndSortVariants_ = function(
  271.     restrictions, variants) {
  272.   if (restrictions) {
  273.     variants = variants.filter((variant) => {
  274.       // This was already checked in another scope, but the compiler doesn't
  275.       // seem to understand that.
  276.       goog.asserts.assert(restrictions, 'Restrictions should exist!');
  278.       return shaka.util.StreamUtils.meetsRestrictions(
  279.           variant, restrictions,
  280.           /* maxHwRes */ {width: Infinity, height: Infinity});
  281.     });
  282.   }
  284.   return variants.sort((v1, v2) => {
  285.     return v1.bandwidth - v2.bandwidth;
  286.   });
  287. };