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.Error');
  24. goog.require('shaka.util.StreamUtils');
  28. /**
  29.  * <p>
  30.  * This defines the default ABR manager for the Player.  An instance of this
  31.  * class is used when no ABR manager is given.
  32.  * </p>
  33.  * <p>
  34.  * The behavior of this class is to take throughput samples using
  35.  * segmentDownloaded to estimate the current network bandwidth.  Then it will
  36.  * use that to choose the streams that best fit the current bandwidth.  It will
  37.  * always pick the highest bandwidth variant it thinks can be played.
  38.  * </p>
  39.  * <p>
  40.  * After initial choices are made, this class will call switchCallback() when
  41.  * there is a better choice.  switchCallback() will not be called more than once
  42.  * per ({@link shaka.abr.SimpleAbrManager.SWITCH_INTERVAL_MS}).
  43.  * </p>
  44.  *
  45.  * @constructor
  46.  * @struct
  47.  * @implements {shakaExtern.AbrManager}
  48.  * @export
  49.  */
  50. shaka.abr.SimpleAbrManager = function() {
  51.   /** @private {?shakaExtern.AbrManager.SwitchCallback} */
  52.   this.switch_ = null;
  54.   /** @private {boolean} */
  55.   this.enabled_ = false;
  57.   /** @private {shaka.abr.EwmaBandwidthEstimator} */
  58.   this.bandwidthEstimator_ = new shaka.abr.EwmaBandwidthEstimator();
  60.   /**
  61.    * A filtered list of Variants to choose from.
  62.    * @private {!Array.<!shakaExtern.Variant>}
  63.    */
  64.   this.variants_ = [];
  66.   /** @private {boolean} */
  67.   this.startupComplete_ = false;
  69.   /**
  70.    * The last wall-clock time, in milliseconds, when streams were chosen.
  71.    *
  72.    * @private {?number}
  73.    */
  74.   this.lastTimeChosenMs_ = null;
  76.   /** @private {?shakaExtern.AbrConfiguration} */
  77.   this.config_ = null;
  78. };
  81. /**
  82.  * @override
  83.  * @export
  84.  */
  85. shaka.abr.SimpleAbrManager.prototype.stop = function() {
  86.   this.switch_ = null;
  87.   this.enabled_ = false;
  88.   this.variants_ = [];
  89.   this.lastTimeChosenMs_ = null;
  91.   // Don't reset |startupComplete_|: if we've left the startup interval then we
  92.   // can start using bandwidth estimates right away if init() is called again.
  93. };
  96. /**
  97.  * @override
  98.  * @export
  99.  */
  100. shaka.abr.SimpleAbrManager.prototype.init = function(switchCallback) {
  101.   this.switch_ = switchCallback;
  102. };
  105. /**
  106.  * @override
  107.  * @export
  108.  */
  109. shaka.abr.SimpleAbrManager.prototype.chooseVariant = function() {
  110.   // Alias.
  111.   var SimpleAbrManager = shaka.abr.SimpleAbrManager;
  113.   // Get sorted Variants.
  114.   var sortedVariants = SimpleAbrManager.filterAndSortVariants_(
  115.       this.config_.restrictions, this.variants_);
  116.   var currentBandwidth = this.bandwidthEstimator_.getBandwidthEstimate(
  117.       this.config_.defaultBandwidthEstimate);
  119.   if (this.variants_.length && !sortedVariants.length) {
  120.     throw new shaka.util.Error(
  121.         shaka.util.Error.Severity.CRITICAL,
  122.         shaka.util.Error.Category.MANIFEST,
  123.         shaka.util.Error.Code.RESTRICTIONS_CANNOT_BE_MET);
  124.   }
  126.   // Start by assuming that we will use the first Stream.
  127.   var chosen = sortedVariants[0] || null;
  129.   for (var i = 0; i < sortedVariants.length; ++i) {
  130.     var variant = sortedVariants[i];
  131.     var nextVariant = sortedVariants[i + 1] || {bandwidth: Infinity};
  133.     var minBandwidth = variant.bandwidth /
  134.                        this.config_.bandwidthDowngradeTarget;
  135.     var maxBandwidth = nextVariant.bandwidth /
  136.                        this.config_.bandwidthUpgradeTarget;
  137.     shaka.log.v2('Bandwidth ranges:',
  138.                  (variant.bandwidth / 1e6).toFixed(3),
  139.                  (minBandwidth / 1e6).toFixed(3),
  140.                  (maxBandwidth / 1e6).toFixed(3));
  142.     if (currentBandwidth >= minBandwidth && currentBandwidth <= maxBandwidth)
  143.       chosen = variant;
  144.   }
  146.   this.lastTimeChosenMs_ = Date.now();
  147.   return chosen;
  148. };
  151. /**
  152.  * @override
  153.  * @export
  154.  */
  155. shaka.abr.SimpleAbrManager.prototype.enable = function() {
  156.   this.enabled_ = true;
  157. };
  160. /**
  161.  * @override
  162.  * @export
  163.  */
  164. shaka.abr.SimpleAbrManager.prototype.disable = function() {
  165.   this.enabled_ = false;
  166. };
  169. /**
  170.  * @override
  171.  * @export
  172.  */
  173. shaka.abr.SimpleAbrManager.prototype.segmentDownloaded = function(
  174.     deltaTimeMs, numBytes) {
  175.   shaka.log.v2('Segment downloaded:',
  176.                'deltaTimeMs=' + deltaTimeMs,
  177.                'numBytes=' + numBytes,
  178.                'lastTimeChosenMs=' + this.lastTimeChosenMs_,
  179.                'enabled=' + this.enabled_);
  180.   goog.asserts.assert(deltaTimeMs >= 0, 'expected a non-negative duration');
  181.   this.bandwidthEstimator_.sample(deltaTimeMs, numBytes);
  183.   if ((this.lastTimeChosenMs_ != null) && this.enabled_)
  184.     this.suggestStreams_();
  185. };
  188. /**
  189.  * @override
  190.  * @export
  191.  */
  192. shaka.abr.SimpleAbrManager.prototype.getBandwidthEstimate = function() {
  193.   return this.bandwidthEstimator_.getBandwidthEstimate(
  194.       this.config_.defaultBandwidthEstimate);
  195. };
  198. /**
  199.  * @override
  200.  * @export
  201.  */
  202. shaka.abr.SimpleAbrManager.prototype.setVariants = function(variants) {
  203.   this.variants_ = variants;
  204. };
  207. /**
  208.  * @override
  209.  * @export
  210.  */
  211. shaka.abr.SimpleAbrManager.prototype.configure = function(config) {
  212.   this.config_ = config;
  213. };
  216. /**
  217.  * Calls switch_() with which Streams to switch to.
  218.  *
  219.  * @private
  220.  */
  221. shaka.abr.SimpleAbrManager.prototype.suggestStreams_ = function() {
  222.   shaka.log.v2('Suggesting Streams...');
  223.   goog.asserts.assert(this.lastTimeChosenMs_ != null,
  224.                       'lastTimeChosenMs_ should not be null');
  226.   if (!this.startupComplete_) {
  227.     // Check if we've got enough data yet.
  228.     if (!this.bandwidthEstimator_.hasGoodEstimate()) {
  229.       shaka.log.v2('Still waiting for a good estimate...');
  230.       return;
  231.     }
  232.     this.startupComplete_ = true;
  233.   } else {
  234.     // Check if we've left the switch interval.
  235.     var now = Date.now();
  236.     var delta = now - this.lastTimeChosenMs_;
  237.     if (delta < this.config_.switchInterval * 1000) {
  238.       shaka.log.v2('Still within switch interval...');
  239.       return;
  240.     }
  241.   }
  243.   var chosenVariant = this.chooseVariant();
  244.   var bandwidthEstimate = this.bandwidthEstimator_.getBandwidthEstimate(
  245.       this.config_.defaultBandwidthEstimate);
  246.   var currentBandwidthKbps = Math.round(bandwidthEstimate / 1000.0);
  248.   shaka.log.debug(
  249.       'Calling switch_(), bandwidth=' + currentBandwidthKbps + ' kbps');
  250.   // If any of these chosen streams are already chosen, Player will filter them
  251.   // out before passing the choices on to StreamingEngine.
  252.   this.switch_(chosenVariant);
  253. };
  256. /**
  257.  * @param {shakaExtern.Restrictions} restrictions
  258.  * @param {!Array.<shakaExtern.Variant>} variants
  259.  * @return {!Array.<shakaExtern.Variant>} variants filtered according to
  260.  *   |restrictions| and sorted in ascending order of bandwidth.
  261.  * @private
  262.  */
  263. shaka.abr.SimpleAbrManager.filterAndSortVariants_ = function(
  264.     restrictions, variants) {
  265.   return variants
  266.       .filter(function(variant) {
  267.         return shaka.util.StreamUtils.meetsRestrictions(
  268.             variant, restrictions,
  269.             /* maxHwRes */ {width: Infinity, height: Infinity});
  270.       })
  271.       .sort(function(v1, v2) {
  272.         return v1.bandwidth - v2.bandwidth;
  273.       });
  274. };