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');
  26. /**
  27.  * Creates a new SimpleAbrManager.
  28.  *
  29.  * @constructor
  30.  * @struct
  31.  * @implements {shakaExtern.AbrManager}
  32.  * @export
  33.  */
  34. shaka.abr.SimpleAbrManager = function() {
  35.   /** @private {?shakaExtern.AbrManager.SwitchCallback} */
  36.   this.switch_ = null;
  38.   /** @private {boolean} */
  39.   this.enabled_ = false;
  41.   /** @private {shaka.abr.EwmaBandwidthEstimator} */
  42.   this.bandwidthEstimator_ = new shaka.abr.EwmaBandwidthEstimator();
  44.   /**
  45.    * The last StreamSets given to us via chooseStreams().
  46.    * @private {Object.<string, shakaExtern.StreamSet>}
  47.    */
  48.   this.streamSetsByType_ = {};
  50.   /**
  51.    * The last Streams chosen.
  52.    * @private {Object.<string, shakaExtern.Stream>}
  53.    */
  54.   this.streamsByType_ = {};
  56.   /** @private {boolean} */
  57.   this.startupComplete_ = false;
  59.   /**
  60.    * The last wall-clock time, in milliseconds, when Streams were chosen via
  61.    * chooseStreams() or switch_().
  62.    *
  63.    * @private {?number}
  64.    */
  65.   this.lastTimeChosenMs_ = null;
  66. };
  69. /**
  70.  * The minimum amount of time that must pass between switches, in milliseconds.
  71.  * This keeps us from changing too often and annoying the user.
  72.  *
  73.  * @const {number}
  74.  */
  75. shaka.abr.SimpleAbrManager.SWITCH_INTERVAL_MS = 8000;
  78. /**
  79.  * The fraction of the estimated bandwidth which we should try to use when
  80.  * upgrading.
  81.  *
  82.  * @private
  83.  * @const {number}
  84.  */
  85. shaka.abr.SimpleAbrManager.BANDWIDTH_UPGRADE_TARGET_ = 0.85;
  88. /**
  89.  * The largest fraction of the estimated bandwidth we should use. We should
  90.  * downgrade to avoid this.
  91.  *
  92.  * @private
  93.  * @const {number}
  94.  */
  95. shaka.abr.SimpleAbrManager.BANDWIDTH_DOWNGRADE_TARGET_ = 0.95;
  98. /**
  99.  * @override
  100.  * @export
  101.  */
  102. shaka.abr.SimpleAbrManager.prototype.stop = function() {
  103.   this.switch_ = null;
  104.   this.enabled_ = false;
  105.   this.streamSetsByType_ = {};
  106.   this.streamsByType_ = {};
  107.   this.lastTimeChosenMs_ = null;
  109.   // Don't reset |startupComplete_|: if we've left the startup interval then we
  110.   // can start using bandwidth estimates right away if init() is called again.
  111. };
  114. /**
  115.  * @override
  116.  * @export
  117.  */
  118. shaka.abr.SimpleAbrManager.prototype.init = function(switchCallback) {
  119.   this.switch_ = switchCallback;
  120. };
  123. /**
  124.  * @override
  125.  * @export
  126.  */
  127. shaka.abr.SimpleAbrManager.prototype.chooseStreams = function(
  128.     streamSetsByType) {
  129.   // Merge StreamSets.  We may have been given a partial list.
  130.   for (var type in streamSetsByType) {
  131.     this.streamSetsByType_[type] = streamSetsByType[type];
  132.   }
  134.   // Choose streams for the specific types requested.
  135.   var chosen = {};
  137.   if ('audio' in streamSetsByType) {
  138.     var audioStream = this.chooseAudioStream_();
  139.     if (audioStream) {
  140.       chosen['audio'] = audioStream;
  141.       this.streamsByType_['audio'] = audioStream;
  142.     } else {
  143.       delete this.streamsByType_['audio'];
  144.     }
  145.   }
  147.   if ('video' in streamSetsByType) {
  148.     var videoStream = this.chooseVideoStream_();
  149.     if (videoStream) {
  150.       chosen['video'] = videoStream;
  151.       this.streamsByType_['video'] = videoStream;
  152.     } else {
  153.       delete this.streamsByType_['video'];
  154.     }
  155.   }
  157.   if ('text' in streamSetsByType) {
  158.     // We don't adapt text, so just choose stream 0.
  159.     chosen['text'] = streamSetsByType['text'].streams[0];
  160.   }
  162.   this.lastTimeChosenMs_ = Date.now();
  163.   return chosen;
  164. };
  167. /**
  168.  * @override
  169.  * @export
  170.  */
  171. shaka.abr.SimpleAbrManager.prototype.enable = function() {
  172.   this.enabled_ = true;
  173. };
  176. /**
  177.  * @override
  178.  * @export
  179.  */
  180. shaka.abr.SimpleAbrManager.prototype.disable = function() {
  181.   this.enabled_ = false;
  182. };
  185. /**
  186.  * @override
  187.  * @export
  188.  */
  189. shaka.abr.SimpleAbrManager.prototype.segmentDownloaded = function(
  190.     startTimeMs, endTimeMs, numBytes) {
  191.   shaka.log.v2('Segment downloaded:',
  192.                'startTimeMs=' + startTimeMs,
  193.                'endTimeMs=' + endTimeMs,
  194.                'numBytes=' + numBytes);
  195.   goog.asserts.assert(endTimeMs >= startTimeMs,
  196.                       'expected a non-negative duration');
  197.   this.bandwidthEstimator_.sample(endTimeMs - startTimeMs, numBytes);
  199.   if ((this.lastTimeChosenMs_ != null) && this.enabled_)
  200.     this.suggestStreams_();
  201. };
  204. /**
  205.  * @override
  206.  * @export
  207.  */
  208. shaka.abr.SimpleAbrManager.prototype.getBandwidthEstimate = function() {
  209.   return this.bandwidthEstimator_.getBandwidthEstimate();
  210. };
  213. /**
  214.  * @override
  215.  * @export
  216.  */
  217. shaka.abr.SimpleAbrManager.prototype.setDefaultEstimate = function(estimate) {
  218.   this.bandwidthEstimator_.setDefaultEstimate(estimate);
  219. };
  222. /**
  223.  * Calls switch_() with which Streams to switch to.
  224.  *
  225.  * @private
  226.  */
  227. shaka.abr.SimpleAbrManager.prototype.suggestStreams_ = function() {
  228.   shaka.log.v2('Suggesting Streams...');
  229.   goog.asserts.assert(this.lastTimeChosenMs_ != null,
  230.                       'lastTimeChosenMs_ should not be null');
  232.   if (!this.startupComplete_) {
  233.     // Check if we've got enough data yet.
  234.     if (!this.bandwidthEstimator_.hasGoodEstimate()) {
  235.       shaka.log.v2('Still waiting for a good estimate...');
  236.       return;
  237.     }
  238.     this.startupComplete_ = true;
  239.   } else {
  240.     // Check if we've left the switch interval.
  241.     var now = Date.now();
  242.     var delta = now - this.lastTimeChosenMs_;
  243.     if (delta < shaka.abr.SimpleAbrManager.SWITCH_INTERVAL_MS) {
  244.       shaka.log.v2('Still within switch interval...');
  245.       return;
  246.     }
  247.   }
  249.   var chosen = this.chooseStreams_();
  250.   var currentBandwidthKbps =
  251.       Math.round(this.bandwidthEstimator_.getBandwidthEstimate() / 1000.0);
  252.   shaka.log.debug(
  253.       'Calling switch_(), bandwidth=' + currentBandwidthKbps + ' kbps');
  254.   // If any of these chosen streams are already chosen, Player will filter them
  255.   // out before passing the choices on to StreamingEngine.
  256.   this.switch_(chosen);
  257. };
  260. /**
  261.  * Chooses which Streams to switch to.
  262.  *
  263.  * @return {!Object.<string, !shakaExtern.Stream>}
  264.  * @private
  265.  */
  266. shaka.abr.SimpleAbrManager.prototype.chooseStreams_ = function() {
  267.   var streamsByType = {};
  269.   // Choose audio Stream.
  270.   var audioStream = this.chooseAudioStream_();
  271.   if (audioStream) {
  272.     streamsByType['audio'] = audioStream;
  273.     this.streamsByType_['audio'] = audioStream;
  274.   }
  276.   // Choose video Stream.
  277.   var videoStream = this.chooseVideoStream_();
  278.   if (videoStream) {
  279.     streamsByType['video'] = videoStream;
  280.     this.streamsByType_['video'] = videoStream;
  281.   }
  283.   this.lastTimeChosenMs_ = Date.now();
  284.   return streamsByType;
  285. };
  288. /**
  289.  * Chooses which audio Stream to switch to.
  290.  *
  291.  * @return {?shakaExtern.Stream}
  292.  * @private
  293.  */
  294. shaka.abr.SimpleAbrManager.prototype.chooseAudioStream_ = function() {
  295.   // Alias.
  296.   var SimpleAbrManager = shaka.abr.SimpleAbrManager;
  298.   // Get sorted audio Streams.
  299.   var audioStreamSet = this.streamSetsByType_['audio'];
  300.   if (!audioStreamSet)
  301.     return null;
  302.   var audioStreams = SimpleAbrManager.sortStreamsByBandwidth_(audioStreamSet);
  304.   // Just pick the middle one.
  305.   // TODO: Implement better audio adaptation.
  306.   return audioStreams[Math.floor(audioStreams.length / 2)];
  307. };
  310. /**
  311.  * Chooses which video Stream to switch to.
  312.  *
  313.  * @return {?shakaExtern.Stream}
  314.  * @private
  315.  */
  316. shaka.abr.SimpleAbrManager.prototype.chooseVideoStream_ = function() {
  317.   // Alias.
  318.   var SimpleAbrManager = shaka.abr.SimpleAbrManager;
  320.   // Get sorted video Streams.
  321.   var videoStreamSet = this.streamSetsByType_['video'];
  322.   if (!videoStreamSet)
  323.     return null;
  324.   var videoStreams = SimpleAbrManager.sortStreamsByBandwidth_(videoStreamSet);
  326.   var audioStream = this.streamsByType_['audio'];
  327.   var audioBandwidth = (audioStream && audioStream.bandwidth) || 0;
  328.   var currentBandwidth = this.bandwidthEstimator_.getBandwidthEstimate();
  330.   // Start by assuming that we will use the first Stream.
  331.   var chosen = videoStreams[0];
  333.   for (var i = 0; i < videoStreams.length; ++i) {
  334.     var stream = videoStreams[i];
  335.     var nextStream = (i + 1 < videoStreams.length) ?
  336.                      videoStreams[i + 1] :
  337.                      {bandwidth: Infinity};
  339.     // Ignore Streams which don't have bandwidth information.
  340.     if (!stream.bandwidth) continue;
  342.     var minBandwidth = (stream.bandwidth + audioBandwidth) /
  343.                        SimpleAbrManager.BANDWIDTH_DOWNGRADE_TARGET_;
  344.     var maxBandwidth = (nextStream.bandwidth + audioBandwidth) /
  345.                        SimpleAbrManager.BANDWIDTH_UPGRADE_TARGET_;
  346.     shaka.log.v2('Bandwidth ranges:',
  347.                  ((stream.bandwidth + audioBandwidth) / 1e6).toFixed(3),
  348.                  (minBandwidth / 1e6).toFixed(3),
  349.                  (maxBandwidth / 1e6).toFixed(3));
  351.     if (currentBandwidth >= minBandwidth && currentBandwidth <= maxBandwidth)
  352.       chosen = stream;
  353.   }
  355.   return chosen;
  356. };
  359. /**
  360.  * @param {!shakaExtern.StreamSet} streamSet
  361.  * @return {!Array.<shakaExtern.Stream>} |streamSet|'s Streams sorted
  362.  *   in ascending order of bandwidth.
  363.  * @private
  364.  */
  365. shaka.abr.SimpleAbrManager.sortStreamsByBandwidth_ = function(streamSet) {
  366.   return streamSet.streams.slice(0)
  367.       .filter(function(s) {
  368.         return s.allowedByApplication && s.allowedByKeySystem;
  369.       })
  370.       .sort(function(s1, s2) { return s1.bandwidth - s2.bandwidth; });
  371. };