Source: lib/abr/simple_abr_manager.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.abr.SimpleAbrManager');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.abr.EwmaBandwidthEstimator');
  11. goog.require('shaka.log');
  12. goog.require('shaka.util.StreamUtils');
  15. /**
  16.  * @summary
  17.  * <p>
  18.  * This defines the default ABR manager for the Player.  An instance of this
  19.  * class is used when no ABR manager is given.
  20.  * </p>
  21.  * <p>
  22.  * The behavior of this class is to take throughput samples using
  23.  * segmentDownloaded to estimate the current network bandwidth.  Then it will
  24.  * use that to choose the streams that best fit the current bandwidth.  It will
  25.  * always pick the highest bandwidth variant it thinks can be played.
  26.  * </p>
  27.  * <p>
  28.  * After initial choices are made, this class will call switchCallback() when
  29.  * there is a better choice.  switchCallback() will not be called more than once
  30.  * per ({@link shaka.abr.SimpleAbrManager.SWITCH_INTERVAL_MS}).
  31.  * </p>
  32.  *
  33.  * @implements {shaka.extern.AbrManager}
  34.  * @export
  35.  */
  36. shaka.abr.SimpleAbrManager = class {
  37.   /** */
  38.   constructor() {
  39.     /** @private {?shaka.extern.AbrManager.SwitchCallback} */
  40.     this.switch_ = null;
  42.     /** @private {boolean} */
  43.     this.enabled_ = false;
  45.     /** @private {shaka.abr.EwmaBandwidthEstimator} */
  46.     this.bandwidthEstimator_ = new shaka.abr.EwmaBandwidthEstimator();
  48.     // Some browsers implement the Network Information API, which allows
  49.     // retrieving information about a user's network connection. We listen
  50.     // to the change event to be able to make quick changes in case the type
  51.     // of connectivity changes.
  52.     if (navigator.connection) {
  53.       navigator.connection.addEventListener('change', () => {
  54.         if (this.config_.useNetworkInformation && this.enabled_) {
  55.           this.bandwidthEstimator_ = new shaka.abr.EwmaBandwidthEstimator();
  56.           if (this.config_) {
  57.             this.bandwidthEstimator_.configure(this.config_.advanced);
  58.           }
  59.           const chosenVariant = this.chooseVariant();
  60.           if (chosenVariant) {
  61.             this.switch_(chosenVariant);
  62.           }
  63.         }
  64.       });
  65.     }
  67.     /**
  68.      * A filtered list of Variants to choose from.
  69.      * @private {!Array.<!shaka.extern.Variant>}
  70.      */
  71.     this.variants_ = [];
  73.     /** @private {number} */
  74.     this.playbackRate_ = 1;
  76.     /** @private {boolean} */
  77.     this.startupComplete_ = false;
  79.     /**
  80.      * The last wall-clock time, in milliseconds, when streams were chosen.
  81.      *
  82.      * @private {?number}
  83.      */
  84.     this.lastTimeChosenMs_ = null;
  86.     /** @private {?shaka.extern.AbrConfiguration} */
  87.     this.config_ = null;
  88.   }
  91.   /**
  92.    * @override
  93.    * @export
  94.    */
  95.   stop() {
  96.     this.switch_ = null;
  97.     this.enabled_ = false;
  98.     this.variants_ = [];
  99.     this.playbackRate_ = 1;
  100.     this.lastTimeChosenMs_ = null;
  102.     // Don't reset |startupComplete_|: if we've left the startup interval, we
  103.     // can start using bandwidth estimates right away after init() is called.
  104.   }
  107.   /**
  108.    * @override
  109.    * @export
  110.    */
  111.   init(switchCallback) {
  112.     this.switch_ = switchCallback;
  113.   }
  116.   /**
  117.    * @override
  118.    * @export
  119.    */
  120.   chooseVariant() {
  121.     const SimpleAbrManager = shaka.abr.SimpleAbrManager;
  123.     // Get sorted Variants.
  124.     let sortedVariants = SimpleAbrManager.filterAndSortVariants_(
  125.         this.config_.restrictions, this.variants_);
  127.     const defaultBandwidthEstimate = this.getDefaultBandwidth_();
  128.     const currentBandwidth = this.bandwidthEstimator_.getBandwidthEstimate(
  129.         defaultBandwidthEstimate);
  131.     if (this.variants_.length && !sortedVariants.length) {
  132.       // If we couldn't meet the ABR restrictions, we should still play
  133.       // something.
  134.       // These restrictions are not "hard" restrictions in the way that
  135.       // top-level or DRM-based restrictions are.  Sort the variants without
  136.       // restrictions and keep just the first (lowest-bandwidth) one.
  137.       shaka.log.warning('No variants met the ABR restrictions. ' +
  138.                         'Choosing a variant by lowest bandwidth.');
  139.       sortedVariants = SimpleAbrManager.filterAndSortVariants_(
  140.           /* restrictions= */ null, this.variants_);
  141.       sortedVariants = [sortedVariants[0]];
  142.     }
  144.     // Start by assuming that we will use the first Stream.
  145.     let chosen = sortedVariants[0] || null;
  147.     for (let i = 0; i < sortedVariants.length; i++) {
  148.       const item = sortedVariants[i];
  149.       const playbackRate =
  150.           !isNaN(this.playbackRate_) ? Math.abs(this.playbackRate_) : 1;
  151.       const itemBandwidth = playbackRate * item.bandwidth;
  152.       const minBandwidth =
  153.           itemBandwidth / this.config_.bandwidthDowngradeTarget;
  154.       let next = {bandwidth: Infinity};
  155.       for (let j = i + 1; j < sortedVariants.length; j++) {
  156.         if (item.bandwidth != sortedVariants[j].bandwidth) {
  157.           next = sortedVariants[j];
  158.           break;
  159.         }
  160.       }
  161.       const nextBandwidth = playbackRate * next.bandwidth;
  162.       const maxBandwidth = nextBandwidth / this.config_.bandwidthUpgradeTarget;
  163.       shaka.log.v2('Bandwidth ranges:',
  164.           (itemBandwidth / 1e6).toFixed(3),
  165.           (minBandwidth / 1e6).toFixed(3),
  166.           (maxBandwidth / 1e6).toFixed(3));
  168.       if (currentBandwidth >= minBandwidth &&
  169.           currentBandwidth <= maxBandwidth &&
  170.           chosen.bandwidth != item.bandwidth) {
  171.         chosen = item;
  172.       }
  173.     }
  175.     this.lastTimeChosenMs_ = Date.now();
  176.     return chosen;
  177.   }
  180.   /**
  181.    * @override
  182.    * @export
  183.    */
  184.   enable() {
  185.     this.enabled_ = true;
  186.   }
  189.   /**
  190.    * @override
  191.    * @export
  192.    */
  193.   disable() {
  194.     this.enabled_ = false;
  195.   }
  198.   /**
  199.    * @override
  200.    * @export
  201.    */
  202.   segmentDownloaded(deltaTimeMs, numBytes) {
  203.     shaka.log.v2('Segment downloaded:',
  204.         'deltaTimeMs=' + deltaTimeMs,
  205.         'numBytes=' + numBytes,
  206.         'lastTimeChosenMs=' + this.lastTimeChosenMs_,
  207.         'enabled=' + this.enabled_);
  208.     goog.asserts.assert(deltaTimeMs >= 0, 'expected a non-negative duration');
  209.     this.bandwidthEstimator_.sample(deltaTimeMs, numBytes);
  211.     if ((this.lastTimeChosenMs_ != null) && this.enabled_) {
  212.       this.suggestStreams_();
  213.     }
  214.   }
  217.   /**
  218.    * @override
  219.    * @export
  220.    */
  221.   getBandwidthEstimate() {
  222.     const defaultBandwidthEstimate = this.getDefaultBandwidth_();
  223.     return this.bandwidthEstimator_.getBandwidthEstimate(
  224.         defaultBandwidthEstimate);
  225.   }
  228.   /**
  229.    * @override
  230.    * @export
  231.    */
  232.   setVariants(variants) {
  233.     this.variants_ = variants;
  234.   }
  237.   /**
  238.    * @override
  239.    * @export
  240.    */
  241.   playbackRateChanged(rate) {
  242.     this.playbackRate_ = rate;
  243.   }
  246.   /**
  247.    * @override
  248.    * @export
  249.    */
  250.   configure(config) {
  251.     this.config_ = config;
  252.     if (this.bandwidthEstimator_ && this.config_) {
  253.       this.bandwidthEstimator_.configure(this.config_.advanced);
  254.     }
  255.   }
  258.   /**
  259.    * Calls switch_() with the variant chosen by chooseVariant().
  260.    *
  261.    * @private
  262.    */
  263.   suggestStreams_() {
  264.     shaka.log.v2('Suggesting Streams...');
  265.     goog.asserts.assert(this.lastTimeChosenMs_ != null,
  266.         'lastTimeChosenMs_ should not be null');
  268.     if (!this.startupComplete_) {
  269.       // Check if we've got enough data yet.
  270.       if (!this.bandwidthEstimator_.hasGoodEstimate()) {
  271.         shaka.log.v2('Still waiting for a good estimate...');
  272.         return;
  273.       }
  274.       this.startupComplete_ = true;
  275.     } else {
  276.       // Check if we've left the switch interval.
  277.       const now = Date.now();
  278.       const delta = now - this.lastTimeChosenMs_;
  279.       if (delta < this.config_.switchInterval * 1000) {
  280.         shaka.log.v2('Still within switch interval...');
  281.         return;
  282.       }
  283.     }
  285.     const chosenVariant = this.chooseVariant();
  286.     const defaultBandwidthEstimate = this.getDefaultBandwidth_();
  287.     const bandwidthEstimate = this.bandwidthEstimator_.getBandwidthEstimate(
  288.         defaultBandwidthEstimate);
  289.     const currentBandwidthKbps = Math.round(bandwidthEstimate / 1000.0);
  291.     if (chosenVariant) {
  292.       shaka.log.debug(
  293.           'Calling switch_(), bandwidth=' + currentBandwidthKbps + ' kbps');
  294.       // If any of these chosen streams are already chosen, Player will filter
  295.       // them out before passing the choices on to StreamingEngine.
  296.       this.switch_(chosenVariant);
  297.     }
  298.   }
  301.   /**
  302.    * @private
  303.    */
  304.   getDefaultBandwidth_() {
  305.     let defaultBandwidthEstimate = this.config_.defaultBandwidthEstimate;
  307.     // Some browsers implement the Network Information API, which allows
  308.     // retrieving information about a user's network connection.  Tizen 3 has
  309.     // NetworkInformation, but not the downlink attribute.
  310.     if (navigator.connection && navigator.connection.downlink &&
  311.         this.config_.useNetworkInformation) {
  312.       // If it's available, get the bandwidth estimate from the browser (in
  313.       // megabits per second) and use it as defaultBandwidthEstimate.
  314.       defaultBandwidthEstimate = navigator.connection.downlink * 1e6;
  315.     }
  316.     return defaultBandwidthEstimate;
  317.   }
  320.   /**
  321.    * @param {?shaka.extern.Restrictions} restrictions
  322.    * @param {!Array.<shaka.extern.Variant>} variants
  323.    * @return {!Array.<shaka.extern.Variant>} variants filtered according to
  324.    *   |restrictions| and sorted in ascending order of bandwidth.
  325.    * @private
  326.    */
  327.   static filterAndSortVariants_(restrictions, variants) {
  328.     if (restrictions) {
  329.       variants = variants.filter((variant) => {
  330.         // This was already checked in another scope, but the compiler doesn't
  331.         // seem to understand that.
  332.         goog.asserts.assert(restrictions, 'Restrictions should exist!');
  334.         return shaka.util.StreamUtils.meetsRestrictions(
  335.             variant, restrictions,
  336.             /* maxHwRes= */ {width: Infinity, height: Infinity});
  337.       });
  338.     }
  340.     return variants.sort((v1, v2) => {
  341.       return v1.bandwidth - v2.bandwidth;
  342.     });
  343.   }
  344. };