Source: lib/util/cmcd_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.CmcdManager');
  9. goog.require('goog.Uri');
  10. goog.require('shaka.log');
  11. goog.require('shaka.net.NetworkingEngine');
  12. goog.require('shaka.util.ArrayUtils');
  13. goog.require('shaka.util.EventManager');
  15. goog.requireType('shaka.media.SegmentReference');
  17. /**
  18.  * @summary
  19.  * A CmcdManager maintains CMCD state as well as a collection of utility
  20.  * functions.
  21.  */
  22. shaka.util.CmcdManager = class {
  23.   /**
  24.    * @param {shaka.util.CmcdManager.PlayerInterface} playerInterface
  25.    * @param {shaka.extern.CmcdConfiguration} config
  26.    */
  27.   constructor(playerInterface, config) {
  28.     /** @private {shaka.util.CmcdManager.PlayerInterface} */
  29.     this.playerInterface_ = playerInterface;
  31.     /** @private {?shaka.extern.CmcdConfiguration} */
  32.     this.config_ = config;
  34.     /**
  35.      * Streaming format
  36.      *
  37.      * @private {(shaka.util.CmcdManager.StreamingFormat|undefined)}
  38.      */
  39.     this.sf_ = undefined;
  41.     /**
  42.      * @private {boolean}
  43.      */
  44.     this.playbackStarted_ = false;
  46.     /**
  47.      * @private {boolean}
  48.      */
  49.     this.buffering_ = true;
  51.     /**
  52.      * @private {boolean}
  53.      */
  54.     this.starved_ = false;
  56.     /**
  57.      * @private {boolean}
  58.      */
  59.     this.lowLatency_ = false;
  61.     /**
  62.      * @private {number|undefined}
  63.      */
  64.     this.playbackPlayTime_ = undefined;
  66.     /**
  67.      * @private {number|undefined}
  68.      */
  69.     this.playbackPlayingTime_ = undefined;
  71.     /**
  72.      * @private {number}
  73.      */
  74.     this.startTimeOfLoad_ = 0;
  76.     /**
  77.      * @private {boolean}
  78.      */
  79.     this.msdSent_ = false;
  81.     /**
  82.      * @private {shaka.util.EventManager}
  83.      */
  84.     this.eventManager_ = new shaka.util.EventManager();
  86.     /** @private {HTMLMediaElement} */
  87.     this.video_ = null;
  88.   }
  91.   /**
  92.    * Set media element and setup event listeners
  93.    * @param {HTMLMediaElement} mediaElement The video element
  94.    */
  95.   setMediaElement(mediaElement) {
  96.     this.video_ = mediaElement;
  97.     this.setupMSDEventListeners_();
  98.   }
  100.   /**
  101.    * Called by the Player to provide an updated configuration any time it
  102.    * changes.
  103.    *
  104.    * @param {shaka.extern.CmcdConfiguration} config
  105.    */
  106.   configure(config) {
  107.     this.config_ = config;
  108.   }
  111.   /**
  112.    * Resets the CmcdManager.
  113.    */
  114.   reset() {
  115.     this.playbackStarted_ = false;
  116.     this.buffering_ = true;
  117.     this.starved_ = false;
  118.     this.lowLatency_ = false;
  119.     this.playbackPlayTime_ = 0;
  120.     this.playbackPlayingTime_ = 0;
  121.     this.startTimeOfLoad_ = 0;
  122.     this.msdSent_ = false;
  123.     this.video_ = null;
  124.     this.eventManager_.removeAll();
  125.   }
  127.   /**
  128.    * Set the buffering state
  129.    *
  130.    * @param {boolean} buffering
  131.    */
  132.   setBuffering(buffering) {
  133.     if (!buffering && !this.playbackStarted_) {
  134.       this.playbackStarted_ = true;
  135.     }
  137.     if (this.playbackStarted_ && buffering) {
  138.       this.starved_ = true;
  139.     }
  141.     this.buffering_ = buffering;
  142.   }
  144.   /**
  145.    * Set the low latency
  146.    *
  147.    * @param {boolean} lowLatency
  148.    */
  149.   setLowLatency(lowLatency) {
  150.     this.lowLatency_ = lowLatency;
  152.     const StreamingFormat = shaka.util.CmcdManager.StreamingFormat;
  153.     if (this.lowLatency_) {
  154.       if (this.sf_ == StreamingFormat.DASH) {
  155.         this.sf_ = StreamingFormat.LOW_LATENCY_DASH;
  156.       } else if (this.sf_ == StreamingFormat.HLS) {
  157.         this.sf_ = StreamingFormat.LOW_LATENCY_HLS;
  158.       }
  159.     } else {
  160.       if (this.sf_ == StreamingFormat.LOW_LATENCY_DASH) {
  161.         this.sf_ = StreamingFormat.DASH;
  162.       } else if (this.sf_ == StreamingFormat.LOW_LATENCY_HLS) {
  163.         this.sf_ = StreamingFormat.HLS;
  164.       }
  165.     }
  166.   }
  168.   /**
  169.    * Set start time of load if autoplay is enabled
  170.    *
  171.    * @param {number} startTimeOfLoad
  172.    */
  173.   setStartTimeOfLoad(startTimeOfLoad) {
  174.     if (!this.config_ || !this.config_.enabled ||
  175.         this.config_.version != shaka.util.CmcdManager.Version.VERSION_2) {
  176.       return;
  177.     }
  178.     if (this.video_ && this.video_.autoplay) {
  179.       const playResult = this.video_.play();
  180.       if (playResult) {
  181.         playResult.then(() => {
  182.           this.startTimeOfLoad_ = startTimeOfLoad;
  183.         }).catch((e) => {
  184.           this.startTimeOfLoad_ = 0;
  185.         });
  186.       }
  187.     }
  188.   }
  190.   /**
  191.    * Apply CMCD data to a request.
  192.    *
  193.    * @param {!shaka.net.NetworkingEngine.RequestType} type
  194.    *   The request type
  195.    * @param {!shaka.extern.Request} request
  196.    *   The request to apply CMCD data to
  197.    * @param {shaka.extern.RequestContext=} context
  198.    *   The request context
  199.    */
  200.   applyData(type, request, context = {}) {
  201.     if (!this.config_.enabled) {
  202.       return;
  203.     }
  205.     if (request.method === 'HEAD') {
  206.       this.apply_(request);
  207.       return;
  208.     }
  210.     const RequestType = shaka.net.NetworkingEngine.RequestType;
  211.     const ObjectType = shaka.util.CmcdManager.ObjectType;
  213.     switch (type) {
  214.       case RequestType.MANIFEST:
  215.         this.applyManifestData(request, context);
  216.         break;
  218.       case RequestType.SEGMENT:
  219.         this.applySegmentData(request, context);
  220.         break;
  222.       case RequestType.LICENSE:
  223.       case RequestType.SERVER_CERTIFICATE:
  224.       case RequestType.KEY:
  225.         this.apply_(request, {ot: ObjectType.KEY});
  226.         break;
  228.       case RequestType.TIMING:
  229.         this.apply_(request, {ot: ObjectType.OTHER});
  230.         break;
  231.     }
  232.   }
  234.   /**
  235.    * Apply CMCD data to a manifest request.
  236.    *
  237.    * @param {!shaka.extern.Request} request
  238.    *   The request to apply CMCD data to
  239.    * @param {shaka.extern.RequestContext} context
  240.    *   The request context
  241.    */
  242.   applyManifestData(request, context) {
  243.     try {
  244.       if (!this.config_.enabled) {
  245.         return;
  246.       }
  248.       if (context.type) {
  249.         this.sf_ = this.getStreamFormat_(context.type);
  250.       }
  252.       this.apply_(request, {
  253.         ot: shaka.util.CmcdManager.ObjectType.MANIFEST,
  254.         su: !this.playbackStarted_,
  255.       });
  256.     } catch (error) {
  257.       shaka.log.warnOnce('CMCD_MANIFEST_ERROR',
  258.           'Could not generate manifest CMCD data.', error);
  259.     }
  260.   }
  262.   /**
  263.    * Apply CMCD data to a segment request
  264.    *
  265.    * @param {!shaka.extern.Request} request
  266.    * @param {shaka.extern.RequestContext} context
  267.    *   The request context
  268.    */
  269.   applySegmentData(request, context) {
  270.     try {
  271.       if (!this.config_.enabled) {
  272.         return;
  273.       }
  275.       const segment = context.segment;
  277.       let duration = 0;
  278.       if (segment) {
  279.         duration = segment.endTime - segment.startTime;
  280.       }
  282.       const data = {
  283.         d: duration * 1000,
  284.         st: this.getStreamType_(),
  285.       };
  287.       data.ot = this.getObjectType_(context);
  289.       const ObjectType = shaka.util.CmcdManager.ObjectType;
  290.       const isMedia = data.ot === ObjectType.VIDEO ||
  291.           data.ot === ObjectType.AUDIO ||
  292.           data.ot === ObjectType.MUXED ||
  293.           data.ot === ObjectType.TIMED_TEXT;
  295.       const stream = context.stream;
  296.       if (stream) {
  297.         const playbackRate = this.playerInterface_.getPlaybackRate();
  298.         if (isMedia) {
  299.           data.bl = this.getBufferLength_(stream.type);
  300.           if (data.ot !== ObjectType.TIMED_TEXT) {
  301.             const remainingBufferLength =
  302.                 this.getRemainingBufferLength_(stream.type);
  303.             if (playbackRate) {
  304.               data.dl = remainingBufferLength / Math.abs(playbackRate);
  305.             } else {
  306.               data.dl = remainingBufferLength;
  307.             }
  308.           }
  309.         }
  311.         if (stream.bandwidth) {
  312.           data.br = stream.bandwidth / 1000;
  313.         }
  315.         if (stream.segmentIndex && segment) {
  316.           const reverse = playbackRate < 0;
  317.           const iterator = stream.segmentIndex.getIteratorForTime(
  318.               segment.endTime, /* allowNonIndependent= */ true, reverse);
  319.           if (iterator) {
  320.             const nextSegment = iterator.next().value;
  321.             if (nextSegment && nextSegment != segment) {
  322.               if (!shaka.util.ArrayUtils.equal(
  323.                   segment.getUris(), nextSegment.getUris())) {
  324.                 data.nor = this.urlToRelativePath_(
  325.                     nextSegment.getUris()[0], request.uris[0]);
  326.               }
  327.               if ((nextSegment.startByte || nextSegment.endByte) &&
  328.                   (segment.startByte != nextSegment.startByte ||
  329.                   segment.endByte != nextSegment.endByte)) {
  330.                 let range = nextSegment.startByte + '-';
  331.                 if (nextSegment.endByte) {
  332.                   range += nextSegment.endByte;
  333.                 }
  334.                 data.nrr = range;
  335.               }
  336.             }
  337.           }
  338.           const rtp = this.calculateRtp_(stream, segment);
  339.           if (!isNaN(rtp)) {
  340.             data.rtp = rtp;
  341.           }
  342.         }
  343.       }
  345.       if (isMedia && data.ot !== ObjectType.TIMED_TEXT) {
  346.         data.tb = this.getTopBandwidth_(data.ot) / 1000;
  347.       }
  349.       this.apply_(request, data);
  350.     } catch (error) {
  351.       shaka.log.warnOnce('CMCD_SEGMENT_ERROR',
  352.           'Could not generate segment CMCD data.', error);
  353.     }
  354.   }
  356.   /**
  357.    * Apply CMCD data to a text request
  358.    *
  359.    * @param {!shaka.extern.Request} request
  360.    */
  361.   applyTextData(request) {
  362.     try {
  363.       if (!this.config_.enabled) {
  364.         return;
  365.       }
  367.       this.apply_(request, {
  368.         ot: shaka.util.CmcdManager.ObjectType.CAPTION,
  369.         su: true,
  370.       });
  371.     } catch (error) {
  372.       shaka.log.warnOnce('CMCD_TEXT_ERROR',
  373.           'Could not generate text CMCD data.', error);
  374.     }
  375.   }
  377.   /**
  378.    * Apply CMCD data to streams loaded via src=.
  379.    *
  380.    * @param {string} uri
  381.    * @param {string} mimeType
  382.    * @return {string}
  383.    */
  384.   appendSrcData(uri, mimeType) {
  385.     try {
  386.       if (!this.config_.enabled) {
  387.         return uri;
  388.       }
  390.       const data = this.createData_();
  391.       data.ot = this.getObjectTypeFromMimeType_(mimeType);
  392.       data.su = true;
  394.       const query = shaka.util.CmcdManager.toQuery(data);
  396.       return shaka.util.CmcdManager.appendQueryToUri(uri, query);
  397.     } catch (error) {
  398.       shaka.log.warnOnce('CMCD_SRC_ERROR',
  399.           'Could not generate src CMCD data.', error);
  400.       return uri;
  401.     }
  402.   }
  404.   /**
  405.    * Apply CMCD data to side car text track uri.
  406.    *
  407.    * @param {string} uri
  408.    * @return {string}
  409.    */
  410.   appendTextTrackData(uri) {
  411.     try {
  412.       if (!this.config_.enabled) {
  413.         return uri;
  414.       }
  416.       const data = this.createData_();
  417.       data.ot = shaka.util.CmcdManager.ObjectType.CAPTION;
  418.       data.su = true;
  420.       const query = shaka.util.CmcdManager.toQuery(data);
  422.       return shaka.util.CmcdManager.appendQueryToUri(uri, query);
  423.     } catch (error) {
  424.       shaka.log.warnOnce('CMCD_TEXT_TRACK_ERROR',
  425.           'Could not generate text track CMCD data.', error);
  426.       return uri;
  427.     }
  428.   }
  430.   /**
  431.    * Set playbackPlayTime_ when the play event is triggered
  432.    * @private
  433.    */
  434.   onPlaybackPlay_() {
  435.     if (!this.playbackPlayTime_) {
  436.       this.playbackPlayTime_ = Date.now();
  437.     }
  438.   }
  440.   /**
  441.    * Set playbackPlayingTime_
  442.    * @private
  443.    */
  444.   onPlaybackPlaying_() {
  445.     if (!this.playbackPlayingTime_) {
  446.       this.playbackPlayingTime_ = Date.now();
  447.     }
  448.   }
  450.   /**
  451.    * Setup event listeners for msd calculation
  452.    * @private
  453.    */
  454.   setupMSDEventListeners_() {
  455.     const onPlaybackPlay = () => this.onPlaybackPlay_();
  456.     this.eventManager_.listenOnce(
  457.         this.video_, 'play', onPlaybackPlay);
  459.     const onPlaybackPlaying = () => this.onPlaybackPlaying_();
  460.     this.eventManager_.listenOnce(
  461.         this.video_, 'playing', onPlaybackPlaying);
  462.   }
  464.   /**
  465.    * Create baseline CMCD data
  466.    *
  467.    * @return {CmcdData}
  468.    * @private
  469.    */
  470.   createData_() {
  471.     if (!this.config_.sessionId) {
  472.       this.config_.sessionId = window.crypto.randomUUID();
  473.     }
  474.     return {
  475.       v: this.config_.version,
  476.       sf: this.sf_,
  477.       sid: this.config_.sessionId,
  478.       cid: this.config_.contentId,
  479.       mtp: this.playerInterface_.getBandwidthEstimate() / 1000,
  480.     };
  481.   }
  483.   /**
  484.    * Apply CMCD data to a request.
  485.    *
  486.    * @param {!shaka.extern.Request} request The request to apply CMCD data to
  487.    * @param {!CmcdData} data The data object
  488.    * @param {boolean} useHeaders Send data via request headers
  489.    * @private
  490.    */
  491.   apply_(request, data = {}, useHeaders = this.config_.useHeaders) {
  492.     if (!this.config_.enabled) {
  493.       return;
  494.     }
  496.     // apply baseline data
  497.     Object.assign(data, this.createData_());
  499.     data.pr = this.playerInterface_.getPlaybackRate();
  501.     const isVideo = data.ot === shaka.util.CmcdManager.ObjectType.VIDEO ||
  502.         data.ot === shaka.util.CmcdManager.ObjectType.MUXED;
  504.     if (this.starved_ && isVideo) {
  505.       data.bs = true;
  506.       data.su = true;
  507.       this.starved_ = false;
  508.     }
  510.     if (data.su == null) {
  511.       data.su = this.buffering_;
  512.     }
  514.     if (data.v === shaka.util.CmcdManager.Version.VERSION_2) {
  515.       if (this.playerInterface_.isLive()) {
  516.         data.ltc = this.playerInterface_.getLiveLatency();
  517.       }
  519.       const msd = this.calculateMSD_();
  520.       if (msd != undefined) {
  521.         data.msd = msd;
  522.         this.msdSent_ = true;
  523.       }
  524.     }
  526.     const output = this.filterKeys_(data);
  528.     if (useHeaders) {
  529.       const headers = shaka.util.CmcdManager.toHeaders(output);
  530.       if (!Object.keys(headers).length) {
  531.         return;
  532.       }
  534.       Object.assign(request.headers, headers);
  535.     } else {
  536.       const query = shaka.util.CmcdManager.toQuery(output);
  537.       if (!query) {
  538.         return;
  539.       }
  541.       request.uris = request.uris.map((uri) => {
  542.         return shaka.util.CmcdManager.appendQueryToUri(uri, query);
  543.       });
  544.     }
  545.   }
  547.   /**
  548.    * Filter the CMCD data object to include only the keys specified in the
  549.    * configuration.
  550.    *
  551.    * @param {CmcdData} data
  552.    * @return {CmcdData}
  553.    * @private
  554.    */
  555.   filterKeys_(data) {
  556.     const includeKeys = this.config_.includeKeys;
  558.     if (!includeKeys.length) {
  559.       return data;
  560.     }
  562.     return Object.keys(data).reduce((acc, key) => {
  563.       if (includeKeys.includes(key)) {
  564.         acc[key] = data[key];
  565.       }
  566.       return acc;
  567.     }, {});
  568.   }
  570.   /**
  571.    * The CMCD object type.
  572.    *
  573.    * @param {shaka.extern.RequestContext} context
  574.    *   The request context
  575.    * @return {shaka.util.CmcdManager.ObjectType|undefined}
  576.    * @private
  577.    */
  578.   getObjectType_(context) {
  579.     if (context.type ===
  580.         shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT) {
  581.       return shaka.util.CmcdManager.ObjectType.INIT;
  582.     }
  584.     const stream = context.stream;
  586.     if (!stream) {
  587.       return undefined;
  588.     }
  590.     const type = stream.type;
  592.     if (type == 'video') {
  593.       if (stream.codecs && stream.codecs.includes(',')) {
  594.         return shaka.util.CmcdManager.ObjectType.MUXED;
  595.       }
  596.       return shaka.util.CmcdManager.ObjectType.VIDEO;
  597.     }
  599.     if (type == 'audio') {
  600.       return shaka.util.CmcdManager.ObjectType.AUDIO;
  601.     }
  603.     if (type == 'text') {
  604.       if (stream.mimeType === 'application/mp4') {
  605.         return shaka.util.CmcdManager.ObjectType.TIMED_TEXT;
  606.       }
  607.       return shaka.util.CmcdManager.ObjectType.CAPTION;
  608.     }
  610.     return undefined;
  611.   }
  613.   /**
  614.    * The CMCD object type from mimeType.
  615.    *
  616.    * @param {!string} mimeType
  617.    * @return {(shaka.util.CmcdManager.ObjectType|undefined)}
  618.    * @private
  619.    */
  620.   getObjectTypeFromMimeType_(mimeType) {
  621.     switch (mimeType.toLowerCase()) {
  622.       case 'audio/mp4':
  623.       case 'audio/webm':
  624.       case 'audio/ogg':
  625.       case 'audio/mpeg':
  626.       case 'audio/aac':
  627.       case 'audio/flac':
  628.       case 'audio/wav':
  629.         return shaka.util.CmcdManager.ObjectType.AUDIO;
  631.       case 'video/webm':
  632.       case 'video/mp4':
  633.       case 'video/mpeg':
  634.       case 'video/mp2t':
  635.         return shaka.util.CmcdManager.ObjectType.MUXED;
  637.       case 'application/x-mpegurl':
  638.       case 'application/vnd.apple.mpegurl':
  639.       case 'application/dash+xml':
  640.       case 'video/vnd.mpeg.dash.mpd':
  641.       case 'application/vnd.ms-sstr+xml':
  642.         return shaka.util.CmcdManager.ObjectType.MANIFEST;
  644.       default:
  645.         return undefined;
  646.     }
  647.   }
  649.   /**
  650.    * Get the buffer length for a media type in milliseconds
  651.    *
  652.    * @param {string} type
  653.    * @return {number}
  654.    * @private
  655.    */
  656.   getBufferLength_(type) {
  657.     const ranges = this.playerInterface_.getBufferedInfo()[type];
  659.     if (!ranges.length) {
  660.       return NaN;
  661.     }
  663.     const start = this.playerInterface_.getCurrentTime();
  664.     const range = ranges.find((r) => r.start <= start && r.end >= start);
  666.     if (!range) {
  667.       return NaN;
  668.     }
  670.     return (range.end - start) * 1000;
  671.   }
  673.   /**
  674.    * Get the remaining buffer length for a media type in milliseconds
  675.    *
  676.    * @param {string} type
  677.    * @return {number}
  678.    * @private
  679.    */
  680.   getRemainingBufferLength_(type) {
  681.     const ranges = this.playerInterface_.getBufferedInfo()[type];
  683.     if (!ranges.length) {
  684.       return 0;
  685.     }
  687.     const start = this.playerInterface_.getCurrentTime();
  688.     const range = ranges.find((r) => r.start <= start && r.end >= start);
  690.     if (!range) {
  691.       return 0;
  692.     }
  694.     return (range.end - start) * 1000;
  695.   }
  697.   /**
  698.    * Constructs a relative path from a URL
  699.    *
  700.    * @param {string} url
  701.    * @param {string} base
  702.    * @return {string}
  703.    * @private
  704.    */
  705.   urlToRelativePath_(url, base) {
  706.     const to = new URL(url);
  707.     const from = new URL(base);
  709.     if (to.origin !== from.origin) {
  710.       return url;
  711.     }
  713.     const toPath = to.pathname.split('/').slice(1);
  714.     const fromPath = from.pathname.split('/').slice(1, -1);
  716.     // remove common parents
  717.     while (toPath[0] === fromPath[0]) {
  718.       toPath.shift();
  719.       fromPath.shift();
  720.     }
  722.     // add back paths
  723.     while (fromPath.length) {
  724.       fromPath.shift();
  725.       toPath.unshift('..');
  726.     }
  728.     return toPath.join('/');
  729.   }
  731.   /**
  732.    * Calculate measured start delay
  733.    *
  734.    * @return {number|undefined}
  735.    * @private
  736.    */
  737.   calculateMSD_() {
  738.     if (!this.msdSent_ &&
  739.         this.playbackPlayingTime_ &&
  740.         this.playbackPlayTime_) {
  741.       const startTime = this.startTimeOfLoad_ || this.playbackPlayTime_;
  742.       return this.playbackPlayingTime_ - startTime;
  743.     }
  744.     return undefined;
  745.   }
  748.   /**
  749.    * Calculate requested maximum throughput
  750.    *
  751.    * @param {shaka.extern.Stream} stream
  752.    * @param {shaka.media.SegmentReference} segment
  753.    * @return {number}
  754.    * @private
  755.    */
  756.   calculateRtp_(stream, segment) {
  757.     const playbackRate = this.playerInterface_.getPlaybackRate() || 1;
  758.     const currentBufferLevel =
  759.         this.getRemainingBufferLength_(stream.type) || 500;
  760.     const bandwidth = stream.bandwidth;
  761.     if (!bandwidth) {
  762.       return NaN;
  763.     }
  764.     const segmentDuration = segment.endTime - segment.startTime;
  765.     // Calculate file size in kilobits
  766.     const segmentSize = bandwidth * segmentDuration / 1000;
  767.     // Calculate time available to load file in seconds
  768.     const timeToLoad = (currentBufferLevel / playbackRate) / 1000;
  769.     // Calculate the exact bandwidth required
  770.     const minBandwidth = segmentSize / timeToLoad;
  771.     // Include a safety buffer
  772.     return minBandwidth * this.config_.rtpSafetyFactor;
  773.   }
  775.   /**
  776.    * Get the stream format
  777.    *
  778.    * @param {shaka.net.NetworkingEngine.AdvancedRequestType} type
  779.    *   The request's advanced type
  780.    * @return {(shaka.util.CmcdManager.StreamingFormat|undefined)}
  781.    * @private
  782.    */
  783.   getStreamFormat_(type) {
  784.     const AdvancedRequestType = shaka.net.NetworkingEngine.AdvancedRequestType;
  786.     switch (type) {
  787.       case AdvancedRequestType.MPD:
  788.         if (this.lowLatency_) {
  789.           return shaka.util.CmcdManager.StreamingFormat.LOW_LATENCY_DASH;
  790.         }
  791.         return shaka.util.CmcdManager.StreamingFormat.DASH;
  793.       case AdvancedRequestType.MASTER_PLAYLIST:
  794.       case AdvancedRequestType.MEDIA_PLAYLIST:
  795.         if (this.lowLatency_) {
  796.           return shaka.util.CmcdManager.StreamingFormat.LOW_LATENCY_HLS;
  797.         }
  798.         return shaka.util.CmcdManager.StreamingFormat.HLS;
  800.       case AdvancedRequestType.MSS:
  801.         return shaka.util.CmcdManager.StreamingFormat.SMOOTH;
  802.     }
  804.     return undefined;
  805.   }
  807.   /**
  808.    * Get the stream type
  809.    *
  810.    * @return {shaka.util.CmcdManager.StreamType}
  811.    * @private
  812.    */
  813.   getStreamType_() {
  814.     const isLive = this.playerInterface_.isLive();
  815.     if (isLive) {
  816.       return shaka.util.CmcdManager.StreamType.LIVE;
  817.     } else {
  818.       return shaka.util.CmcdManager.StreamType.VOD;
  819.     }
  820.   }
  822.   /**
  823.    * Get the highest bandwidth for a given type.
  824.    *
  825.    * @param {shaka.util.CmcdManager.ObjectType|undefined} type
  826.    * @return {number}
  827.    * @private
  828.    */
  829.   getTopBandwidth_(type) {
  830.     const variants = this.playerInterface_.getVariantTracks();
  831.     if (!variants.length) {
  832.       return NaN;
  833.     }
  835.     let top = variants[0];
  837.     for (const variant of variants) {
  838.       if (variant.type === 'variant' && variant.bandwidth > top.bandwidth) {
  839.         top = variant;
  840.       }
  841.     }
  843.     const ObjectType = shaka.util.CmcdManager.ObjectType;
  845.     switch (type) {
  846.       case ObjectType.VIDEO:
  847.         return top.videoBandwidth || NaN;
  849.       case ObjectType.AUDIO:
  850.         return top.audioBandwidth || NaN;
  852.       default:
  853.         return top.bandwidth;
  854.     }
  855.   }
  857.   /**
  858.    * Serialize a CMCD data object according to the rules defined in the
  859.    * section 3.2 of
  860.    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
  861.    *
  862.    * @param {CmcdData} data The CMCD data object
  863.    * @return {string}
  864.    */
  865.   static serialize(data) {
  866.     const results = [];
  867.     const isValid = (value) =>
  868.       !Number.isNaN(value) && value != null && value !== '' && value !== false;
  869.     const toRounded = (value) => Math.round(value);
  870.     const toHundred = (value) => toRounded(value / 100) * 100;
  871.     const toUrlSafe = (value) => encodeURIComponent(value);
  872.     const formatters = {
  873.       br: toRounded,
  874.       d: toRounded,
  875.       bl: toHundred,
  876.       dl: toHundred,
  877.       mtp: toHundred,
  878.       nor: toUrlSafe,
  879.       rtp: toHundred,
  880.       tb: toRounded,
  881.     };
  883.     const keys = Object.keys(data || {}).sort();
  885.     for (const key of keys) {
  886.       let value = data[key];
  888.       // ignore invalid values
  889.       if (!isValid(value)) {
  890.         continue;
  891.       }
  893.       // Version should only be reported if not equal to 1.
  894.       if (key === 'v' && value === 1) {
  895.         continue;
  896.       }
  898.       // Playback rate should only be sent if not equal to 1.
  899.       if (key == 'pr' && value === 1) {
  900.         continue;
  901.       }
  903.       // Certain values require special formatting
  904.       const formatter = formatters[key];
  905.       if (formatter) {
  906.         value = formatter(value);
  907.       }
  909.       // Serialize the key/value pair
  910.       const type = typeof value;
  911.       let result;
  913.       if (type === 'string' && key !== 'ot' && key !== 'sf' && key !== 'st') {
  914.         result = `${key}=${JSON.stringify(value)}`;
  915.       } else if (type === 'boolean') {
  916.         result = key;
  917.       } else if (type === 'symbol') {
  918.         result = `${key}=${value.description}`;
  919.       } else {
  920.         result = `${key}=${value}`;
  921.       }
  923.       results.push(result);
  924.     }
  926.     return results.join(',');
  927.   }
  929.   /**
  930.    * Convert a CMCD data object to request headers according to the rules
  931.    * defined in the section 2.1 and 3.2 of
  932.    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
  933.    *
  934.    * @param {CmcdData} data The CMCD data object
  935.    * @return {!Object}
  936.    */
  937.   static toHeaders(data) {
  938.     const keys = Object.keys(data);
  939.     const headers = {};
  940.     const headerNames = ['Object', 'Request', 'Session', 'Status'];
  941.     const headerGroups = [{}, {}, {}, {}];
  942.     const headerMap = {
  943.       br: 0, d: 0, ot: 0, tb: 0,
  944.       bl: 1, dl: 1, mtp: 1, nor: 1, nrr: 1, su: 1, ltc: 1,
  945.       cid: 2, pr: 2, sf: 2, sid: 2, st: 2, v: 2, msd: 2,
  946.       bs: 3, rtp: 3,
  947.     };
  949.     for (const key of keys) {
  950.       // Unmapped fields are mapped to the Request header
  951.       const index = (headerMap[key] != null) ? headerMap[key] : 1;
  952.       headerGroups[index][key] = data[key];
  953.     }
  955.     for (let i = 0; i < headerGroups.length; i++) {
  956.       const value = shaka.util.CmcdManager.serialize(headerGroups[i]);
  957.       if (value) {
  958.         headers[`CMCD-${headerNames[i]}`] = value;
  959.       }
  960.     }
  962.     return headers;
  963.   }
  965.   /**
  966.    * Convert a CMCD data object to query args according to the rules
  967.    * defined in the section 2.2 and 3.2 of
  968.    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
  969.    *
  970.    * @param {CmcdData} data The CMCD data object
  971.    * @return {string}
  972.    */
  973.   static toQuery(data) {
  974.     return shaka.util.CmcdManager.serialize(data);
  975.   }
  977.   /**
  978.    * Append query args to a uri.
  979.    *
  980.    * @param {string} uri
  981.    * @param {string} query
  982.    * @return {string}
  983.    */
  984.   static appendQueryToUri(uri, query) {
  985.     if (!query) {
  986.       return uri;
  987.     }
  989.     if (uri.includes('offline:')) {
  990.       return uri;
  991.     }
  993.     const url = new goog.Uri(uri);
  994.     url.getQueryData().set('CMCD', query);
  995.     return url.toString();
  996.   }
  997. };
  1000. /**
  1001.  * @typedef {{
  1002.  *   getBandwidthEstimate: function():number,
  1003.  *   getBufferedInfo: function():shaka.extern.BufferedInfo,
  1004.  *   getCurrentTime: function():number,
  1005.  *   getPlaybackRate: function():number,
  1006.  *   getVariantTracks: function():Array<shaka.extern.Track>,
  1007.  *   isLive: function():boolean,
  1008.  *   getLiveLatency: function():number
  1009.  * }}
  1010.  *
  1011.  * @property {function():number} getBandwidthEstimate
  1012.  *   Get the estimated bandwidth in bits per second.
  1013.  * @property {function():shaka.extern.BufferedInfo} getBufferedInfo
  1014.  *   Get information about what the player has buffered.
  1015.  * @property {function():number} getCurrentTime
  1016.  *   Get the current time
  1017.  * @property {function():number} getPlaybackRate
  1018.  *   Get the playback rate
  1019.  * @property {function():Array<shaka.extern.Track>} getVariantTracks
  1020.  *   Get the variant tracks
  1021.  * @property {function():boolean} isLive
  1022.  *   Get if the player is playing live content.
  1023.  * @property {function():number} getLiveLatency
  1024.  *   Get latency in milliseconds between the live edge and what's currently
  1025.  *   playing.
  1026.  */
  1027. shaka.util.CmcdManager.PlayerInterface;
  1030. /**
  1031.  * @enum {string}
  1032.  */
  1033. shaka.util.CmcdManager.ObjectType = {
  1034.   MANIFEST: 'm',
  1035.   AUDIO: 'a',
  1036.   VIDEO: 'v',
  1037.   MUXED: 'av',
  1038.   INIT: 'i',
  1039.   CAPTION: 'c',
  1040.   TIMED_TEXT: 'tt',
  1041.   KEY: 'k',
  1042.   OTHER: 'o',
  1043. };
  1045. /**
  1046.  * @enum {number}
  1047.  */
  1048. shaka.util.CmcdManager.Version = {
  1049.   VERSION_1: 1,
  1050.   VERSION_2: 2,
  1051. };
  1053. /**
  1054.  * @enum {string}
  1055.  */
  1056. shaka.util.CmcdManager.StreamType = {
  1057.   VOD: 'v',
  1058.   LIVE: 'l',
  1059. };
  1062. /**
  1063.  * @enum {string}
  1064.  * @export
  1065.  */
  1066. shaka.util.CmcdManager.StreamingFormat = {
  1067.   DASH: 'd',
  1068.   LOW_LATENCY_DASH: 'ld',
  1069.   HLS: 'h',
  1070.   LOW_LATENCY_HLS: 'lh',
  1071.   SMOOTH: 's',
  1072.   OTHER: 'o',
  1073. };