Source: lib/util/cmsd_manager.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.CmsdManager');
  9. goog.require('shaka.log');
  12. /**
  13.  * @summary
  14.  * A CmsdManager maintains CMSD state as well as a collection of utility
  15.  * functions.
  16.  * @export
  17.  */
  18. shaka.util.CmsdManager = class {
  19.   /**
  20.    * @param {shaka.extern.CmsdConfiguration} config
  21.    */
  22.   constructor(config) {
  23.     /** @private {shaka.extern.CmsdConfiguration} */
  24.     this.config_ = config;
  26.     /** @private {?Map<string, (boolean | number | string)>} */
  27.     this.staticParams_ = null;
  29.     /** @private {?Map<string, (boolean | number | string)>} */
  30.     this.dynamicParams_ = null;
  31.   }
  33.   /**
  34.    * Called by the Player to provide an updated configuration any time it
  35.    * changes.
  36.    *
  37.    * @param {shaka.extern.CmsdConfiguration} config
  38.    */
  39.   configure(config) {
  40.     this.config_ = config;
  41.   }
  44.   /**
  45.    * Resets the CmsdManager.
  46.    */
  47.   reset() {
  48.     this.staticParams_ = null;
  49.     this.dynamicParams_ = null;
  50.   }
  52.   /**
  53.    * Called by the Player to provide the headers of the latest request.
  54.    *
  55.    * @param {!Object<string, string>} headers
  56.    */
  57.   processHeaders(headers) {
  58.     if (!this.config_.enabled) {
  59.       return;
  60.     }
  61.     const CmsdManager = shaka.util.CmsdManager;
  62.     const cmsdStatic = headers[CmsdManager.CMSD_STATIC_HEADER_NAME_];
  63.     if (cmsdStatic) {
  64.       const staticParams = this.parseCMSDStatic_(cmsdStatic);
  65.       if (staticParams) {
  66.         this.staticParams_ = staticParams;
  67.       }
  68.     }
  69.     const cmsdDynamic = headers[CmsdManager.CMSD_DYNAMIC_HEADER_NAME_];
  70.     if (cmsdDynamic) {
  71.       const dynamicParams = this.parseCMSDDynamic_(cmsdDynamic);
  72.       if (dynamicParams) {
  73.         this.dynamicParams_ = dynamicParams;
  74.       }
  75.     }
  76.   }
  78.   /**
  79.    * Returns the max bitrate in bits per second. If there is no max bitrate or
  80.    * it's not enabled, it returns null.
  81.    *
  82.    * @return {?number}
  83.    * @export
  84.    */
  85.   getMaxBitrate() {
  86.     const key = shaka.util.CmsdManager.KEYS_.MAX_SUGGESTED_BITRATE;
  87.     if (!this.config_.enabled || !this.config_.applyMaximumSuggestedBitrate ||
  88.         !this.dynamicParams_ || !this.dynamicParams_.has(key)) {
  89.       return null;
  90.     }
  91.     return /** @type {number} */(this.dynamicParams_.get(key)) * 1000;
  92.   }
  94.   /**
  95.    * Returns the estimated throughput in bits per second. If there is no
  96.    * estimated throughput or it's not enabled, it returns null.
  97.    *
  98.    * @return {?number}
  99.    * @export
  100.    */
  101.   getEstimatedThroughput() {
  102.     const key = shaka.util.CmsdManager.KEYS_.ESTIMATED_THROUGHPUT;
  103.     if (!this.config_.enabled || !this.dynamicParams_ ||
  104.         !this.dynamicParams_.has(key)) {
  105.       return null;
  106.     }
  107.     return /** @type {number} */(this.dynamicParams_.get(key)) * 1000;
  108.   }
  110.   /**
  111.    * Returns the response delay in milliseconds. If there is no response delay
  112.    * or it's not enabled, it returns null.
  113.    *
  114.    * @return {?number}
  115.    * @export
  116.    */
  117.   getResponseDelay() {
  118.     const key = shaka.util.CmsdManager.KEYS_.RESPONSE_DELAY;
  119.     if (!this.config_.enabled || !this.dynamicParams_ ||
  120.         !this.dynamicParams_.has(key)) {
  121.       return null;
  122.     }
  123.     return /** @type {number} */(this.dynamicParams_.get(key));
  124.   }
  126.   /**
  127.    * Returns the RTT in milliseconds. If there is no RTT or it's not enabled,
  128.    * it returns null.
  129.    *
  130.    * @return {?number}
  131.    * @export
  132.    */
  133.   getRoundTripTime() {
  134.     const key = shaka.util.CmsdManager.KEYS_.ROUND_TRIP_TIME;
  135.     if (!this.config_.enabled || !this.dynamicParams_ ||
  136.         !this.dynamicParams_.has(key)) {
  137.       return null;
  138.     }
  139.     return /** @type {number} */(this.dynamicParams_.get(key));
  140.   }
  142.   /**
  143.    * Gets the current bandwidth estimate.
  144.    *
  145.    * @param {number} defaultEstimate
  146.    * @return {number} The bandwidth estimate in bits per second.
  147.    * @export
  148.    */
  149.   getBandwidthEstimate(defaultEstimate) {
  150.     const estimatedThroughput = this.getEstimatedThroughput();
  151.     if (!estimatedThroughput) {
  152.       return defaultEstimate;
  153.     }
  154.     const etpWeightRatio = this.config_.estimatedThroughputWeightRatio;
  155.     if (etpWeightRatio > 0 && etpWeightRatio <= 1) {
  156.       return (defaultEstimate * (1 - etpWeightRatio)) +
  157.           (estimatedThroughput * etpWeightRatio);
  158.     }
  159.     return defaultEstimate;
  160.   }
  162.   /**
  163.    * @param {string} headerValue
  164.    * @return {?Map<string, (boolean | number | string)>}
  165.    * @private
  166.    */
  167.   parseCMSDStatic_(headerValue) {
  168.     try {
  169.       const params = new Map();
  170.       const items = headerValue.split(',');
  171.       for (let i = 0; i < items.length; i++) {
  172.         // <key>=<value>
  173.         const substrings = items[i].split('=');
  174.         const key = substrings[0];
  175.         const value = this.parseParameterValue_(substrings[1]);
  176.         params.set(key, value);
  177.       }
  178.       return params;
  179.     } catch (e) {
  180.       shaka.log.warning(
  181.           'Failed to parse CMSD-Static response header value:', e);
  182.       return null;
  183.     }
  184.   }
  186.   /**
  187.    * @param {string} headerValue
  188.    * @return {?Map<string, (boolean | number | string)>}
  189.    * @private
  190.    */
  191.   parseCMSDDynamic_(headerValue) {
  192.     try {
  193.       const params = new Map();
  194.       const items = headerValue.split(';');
  195.       // Server identifier as 1st item
  196.       for (let i = 1; i < items.length; i++) {
  197.         // <key>=<value>
  198.         const substrings = items[i].split('=');
  199.         const key = substrings[0];
  200.         const value = this.parseParameterValue_(substrings[1]);
  201.         params.set(key, value);
  202.       }
  203.       return params;
  204.     } catch (e) {
  205.       shaka.log.warning(
  206.           'Failed to parse CMSD-Dynamic response header value:', e);
  207.       return null;
  208.     }
  209.   }
  211.   /**
  212.    * @param {string} value
  213.    * @return {(boolean|number|string)}
  214.    * @private
  215.    */
  216.   parseParameterValue_(value) {
  217.     // If the value type is BOOLEAN and the value is TRUE, then the equals
  218.     // sign and the value are omitted
  219.     if (!value) {
  220.       return true;
  221.     }
  222.     // Check if boolean 'false'
  223.     if (value.toLowerCase() === 'false') {
  224.       return false;
  225.     }
  226.     // Check if a number
  227.     if (/^[-0-9]/.test(value)) {
  228.       return parseInt(value, 10);
  229.     }
  230.     // Value is a string, remove double quotes from string value
  231.     return value.replace(/["]+/g, '');
  232.   }
  233. };
  235. /**
  236.  * @const {string}
  237.  * @private
  238.  */
  239. shaka.util.CmsdManager.CMSD_STATIC_HEADER_NAME_ = 'cmsd-static';
  241. /**
  242.  * @const {string}
  243.  * @private
  244.  */
  245. shaka.util.CmsdManager.CMSD_DYNAMIC_HEADER_NAME_ = 'cmsd-dynamic';
  247. /**
  248.  * @enum {string}
  249.  * @private
  250.  */
  251. shaka.util.CmsdManager.KEYS_ = {
  252.   AVAILABILITY_TIME: 'at',
  253.   DURESS: 'du',
  254.   ENCODED_BITRATE: 'br',
  255.   ESTIMATED_THROUGHPUT: 'etp',
  256.   HELD_TIME: 'ht',
  257.   INTERMEDIARY_IDENTIFIER: 'n',
  258.   MAX_SUGGESTED_BITRATE: 'mb',
  259.   NEXT_OBJECT_RESPONSE: 'nor',
  260.   NEXT_RANGE_RESPONSE: 'nrr',
  261.   OBJECT_DURATION: 'd',
  262.   OBJECT_TYPE: 'ot',
  263.   RESPONSE_DELAY: 'rd',
  264.   ROUND_TRIP_TIME: 'rtt',
  265.   STARTUP: 'su',
  266.   STREAM_TYPE: 'st',
  267.   STREAMING_FORMAT: 'sf',
  268.   VERSION: 'v',
  269. };