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.   applyRequestData(type, request, context = {}) {
  201.     if (!this.config_.enabled) {
  202.       return;
  203.     }
  205.     if (request.method === 'HEAD') {
  206.       this.applyRequest_(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.applyRequestSegmentData(request, context);
  220.         break;
  222.       case RequestType.LICENSE:
  223.       case RequestType.SERVER_CERTIFICATE:
  224.       case RequestType.KEY:
  225.         this.applyRequest_(request, {ot: ObjectType.KEY});
  226.         break;
  228.       case RequestType.TIMING:
  229.         this.applyRequest_(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.applyRequest_(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.   applyRequestSegmentData(request, context) {
  270.     try {
  271.       if (!this.config_.enabled) {
  272.         return;
  273.       }
  274.       const data = this.getDataForSegment_(context, request.uris[0]);
  275.       this.applyRequest_(request, data);
  276.     } catch (error) {
  277.       shaka.log.warnOnce('CMCD_SEGMENT_ERROR',
  278.           'Could not generate segment CMCD data.', error);
  279.     }
  280.   }
  282.   /**
  283.    * Apply CMCD data to a text request
  284.    *
  285.    * @param {!shaka.extern.Request} request
  286.    */
  287.   applyTextData(request) {
  288.     try {
  289.       if (!this.config_.enabled) {
  290.         return;
  291.       }
  293.       this.applyRequest_(request, {
  294.         ot: shaka.util.CmcdManager.ObjectType.CAPTION,
  295.         su: true,
  296.       });
  297.     } catch (error) {
  298.       shaka.log.warnOnce('CMCD_TEXT_ERROR',
  299.           'Could not generate text CMCD data.', error);
  300.     }
  301.   }
  303.   /**
  304.    * Apply CMCD data to streams loaded via src=.
  305.    *
  306.    * @param {string} uri
  307.    * @param {string} mimeType
  308.    * @return {string}
  309.    */
  310.   appendSrcData(uri, mimeType) {
  311.     try {
  312.       if (!this.config_.enabled) {
  313.         return uri;
  314.       }
  316.       const data = this.createData_();
  317.       data.ot = this.getObjectTypeFromMimeType_(mimeType);
  318.       data.su = true;
  320.       const query = shaka.util.CmcdManager.toQuery(data);
  322.       return shaka.util.CmcdManager.appendQueryToUri(uri, query);
  323.     } catch (error) {
  324.       shaka.log.warnOnce('CMCD_SRC_ERROR',
  325.           'Could not generate src CMCD data.', error);
  326.       return uri;
  327.     }
  328.   }
  330.   /**
  331.    * Apply CMCD data to side car text track uri.
  332.    *
  333.    * @param {string} uri
  334.    * @return {string}
  335.    */
  336.   appendTextTrackData(uri) {
  337.     try {
  338.       if (!this.config_.enabled) {
  339.         return uri;
  340.       }
  342.       const data = this.createData_();
  343.       data.ot = shaka.util.CmcdManager.ObjectType.CAPTION;
  344.       data.su = true;
  346.       const query = shaka.util.CmcdManager.toQuery(data);
  348.       return shaka.util.CmcdManager.appendQueryToUri(uri, query);
  349.     } catch (error) {
  350.       shaka.log.warnOnce('CMCD_TEXT_TRACK_ERROR',
  351.           'Could not generate text track CMCD data.', error);
  352.       return uri;
  353.     }
  354.   }
  356.   /**
  357.    * Set playbackPlayTime_ when the play event is triggered
  358.    * @private
  359.    */
  360.   onPlaybackPlay_() {
  361.     if (!this.playbackPlayTime_) {
  362.       this.playbackPlayTime_ = Date.now();
  363.     }
  364.   }
  366.   /**
  367.    * Set playbackPlayingTime_
  368.    * @private
  369.    */
  370.   onPlaybackPlaying_() {
  371.     if (!this.playbackPlayingTime_) {
  372.       this.playbackPlayingTime_ = Date.now();
  373.     }
  374.   }
  376.   /**
  377.    * Setup event listeners for msd calculation
  378.    * @private
  379.    */
  380.   setupMSDEventListeners_() {
  381.     const onPlaybackPlay = () => this.onPlaybackPlay_();
  382.     this.eventManager_.listenOnce(
  383.         this.video_, 'play', onPlaybackPlay);
  385.     const onPlaybackPlaying = () => this.onPlaybackPlaying_();
  386.     this.eventManager_.listenOnce(
  387.         this.video_, 'playing', onPlaybackPlaying);
  388.   }
  390.   /**
  391.    * Create baseline CMCD data
  392.    *
  393.    * @return {CmcdData}
  394.    * @private
  395.    */
  396.   createData_() {
  397.     if (!this.config_.sessionId) {
  398.       this.config_.sessionId = window.crypto.randomUUID();
  399.     }
  400.     return {
  401.       v: this.config_.version,
  402.       sf: this.sf_,
  403.       sid: this.config_.sessionId,
  404.       cid: this.config_.contentId,
  405.       mtp: this.playerInterface_.getBandwidthEstimate() / 1000,
  406.     };
  407.   }
  409.   /**
  410.    * Apply CMCD data to a request.
  411.    *
  412.    * @param {!shaka.extern.Request} request The request to apply CMCD data to
  413.    * @param {!CmcdData} data The data object
  414.    * @param {boolean} useHeaders Send data via request headers
  415.    * @private
  416.    */
  417.   applyRequest_(request, data = {}, useHeaders = this.config_.useHeaders) {
  418.     if (!this.config_.enabled) {
  419.       return;
  420.     }
  422.     const output = this.getGenericData_(data);
  424.     if (useHeaders) {
  425.       const headers = shaka.util.CmcdManager.toHeaders(output);
  426.       if (!Object.keys(headers).length) {
  427.         return;
  428.       }
  430.       Object.assign(request.headers, headers);
  431.     } else {
  432.       const query = shaka.util.CmcdManager.toQuery(output);
  433.       if (!query) {
  434.         return;
  435.       }
  437.       request.uris = request.uris.map((uri) => {
  438.         return shaka.util.CmcdManager.appendQueryToUri(uri, query);
  439.       });
  440.     }
  441.   }
  443.   /**
  444.    * Filter the CMCD data object to include only the keys specified in the
  445.    * configuration.
  446.    *
  447.    * @param {CmcdData} data
  448.    * @return {CmcdData}
  449.    * @private
  450.    */
  451.   filterKeys_(data) {
  452.     const includeKeys = this.config_.includeKeys;
  454.     if (!includeKeys.length) {
  455.       return data;
  456.     }
  458.     return Object.keys(data).reduce((acc, key) => {
  459.       if (includeKeys.includes(key)) {
  460.         acc[key] = data[key];
  461.       }
  462.       return acc;
  463.     }, {});
  464.   }
  466.   /**
  467.    * The CMCD object type.
  468.    *
  469.    * @param {shaka.extern.RequestContext} context
  470.    *   The request context
  471.    * @return {shaka.util.CmcdManager.ObjectType|undefined}
  472.    * @private
  473.    */
  474.   getObjectType_(context) {
  475.     if (context.type ===
  476.         shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT) {
  477.       return shaka.util.CmcdManager.ObjectType.INIT;
  478.     }
  480.     const stream = context.stream;
  482.     if (!stream) {
  483.       return undefined;
  484.     }
  486.     const type = stream.type;
  488.     if (type == 'video') {
  489.       if (stream.codecs && stream.codecs.includes(',')) {
  490.         return shaka.util.CmcdManager.ObjectType.MUXED;
  491.       }
  492.       return shaka.util.CmcdManager.ObjectType.VIDEO;
  493.     }
  495.     if (type == 'audio') {
  496.       return shaka.util.CmcdManager.ObjectType.AUDIO;
  497.     }
  499.     if (type == 'text') {
  500.       if (stream.mimeType === 'application/mp4') {
  501.         return shaka.util.CmcdManager.ObjectType.TIMED_TEXT;
  502.       }
  503.       return shaka.util.CmcdManager.ObjectType.CAPTION;
  504.     }
  506.     return undefined;
  507.   }
  509.   /**
  510.    * The CMCD object type from mimeType.
  511.    *
  512.    * @param {!string} mimeType
  513.    * @return {(shaka.util.CmcdManager.ObjectType|undefined)}
  514.    * @private
  515.    */
  516.   getObjectTypeFromMimeType_(mimeType) {
  517.     switch (mimeType.toLowerCase()) {
  518.       case 'audio/mp4':
  519.       case 'audio/webm':
  520.       case 'audio/ogg':
  521.       case 'audio/mpeg':
  522.       case 'audio/aac':
  523.       case 'audio/flac':
  524.       case 'audio/wav':
  525.         return shaka.util.CmcdManager.ObjectType.AUDIO;
  527.       case 'video/webm':
  528.       case 'video/mp4':
  529.       case 'video/mpeg':
  530.       case 'video/mp2t':
  531.         return shaka.util.CmcdManager.ObjectType.MUXED;
  533.       case 'application/x-mpegurl':
  534.       case 'application/vnd.apple.mpegurl':
  535.       case 'application/dash+xml':
  536.       case 'video/vnd.mpeg.dash.mpd':
  537.       case 'application/vnd.ms-sstr+xml':
  538.         return shaka.util.CmcdManager.ObjectType.MANIFEST;
  540.       default:
  541.         return undefined;
  542.     }
  543.   }
  545.   /**
  546.    * Get the buffer length for a media type in milliseconds
  547.    *
  548.    * @param {string} type
  549.    * @return {number}
  550.    * @private
  551.    */
  552.   getBufferLength_(type) {
  553.     const ranges = this.playerInterface_.getBufferedInfo()[type];
  555.     if (!ranges.length) {
  556.       return NaN;
  557.     }
  559.     const start = this.playerInterface_.getCurrentTime();
  560.     const range = ranges.find((r) => r.start <= start && r.end >= start);
  562.     if (!range) {
  563.       return NaN;
  564.     }
  566.     return (range.end - start) * 1000;
  567.   }
  569.   /**
  570.    * Get the remaining buffer length for a media type in milliseconds
  571.    *
  572.    * @param {string} type
  573.    * @return {number}
  574.    * @private
  575.    */
  576.   getRemainingBufferLength_(type) {
  577.     const ranges = this.playerInterface_.getBufferedInfo()[type];
  579.     if (!ranges.length) {
  580.       return 0;
  581.     }
  583.     const start = this.playerInterface_.getCurrentTime();
  584.     const range = ranges.find((r) => r.start <= start && r.end >= start);
  586.     if (!range) {
  587.       return 0;
  588.     }
  590.     return (range.end - start) * 1000;
  591.   }
  593.   /**
  594.    * Constructs a relative path from a URL
  595.    *
  596.    * @param {string} url
  597.    * @param {string} base
  598.    * @return {string}
  599.    * @private
  600.    */
  601.   urlToRelativePath_(url, base) {
  602.     const to = new URL(url);
  603.     const from = new URL(base);
  605.     if (to.origin !== from.origin) {
  606.       return url;
  607.     }
  609.     const toPath = to.pathname.split('/').slice(1);
  610.     const fromPath = from.pathname.split('/').slice(1, -1);
  612.     // remove common parents
  613.     while (toPath[0] === fromPath[0]) {
  614.       toPath.shift();
  615.       fromPath.shift();
  616.     }
  618.     // add back paths
  619.     while (fromPath.length) {
  620.       fromPath.shift();
  621.       toPath.unshift('..');
  622.     }
  624.     return toPath.join('/');
  625.   }
  627.   /**
  628.    * Calculate measured start delay
  629.    *
  630.    * @return {number|undefined}
  631.    * @private
  632.    */
  633.   calculateMSD_() {
  634.     if (!this.msdSent_ &&
  635.         this.playbackPlayingTime_ &&
  636.         this.playbackPlayTime_) {
  637.       const startTime = this.startTimeOfLoad_ || this.playbackPlayTime_;
  638.       return this.playbackPlayingTime_ - startTime;
  639.     }
  640.     return undefined;
  641.   }
  644.   /**
  645.    * Calculate requested maximum throughput
  646.    *
  647.    * @param {shaka.extern.Stream} stream
  648.    * @param {shaka.media.SegmentReference} segment
  649.    * @return {number}
  650.    * @private
  651.    */
  652.   calculateRtp_(stream, segment) {
  653.     const playbackRate = this.playerInterface_.getPlaybackRate() || 1;
  654.     const currentBufferLevel =
  655.         this.getRemainingBufferLength_(stream.type) || 500;
  656.     const bandwidth = stream.bandwidth;
  657.     if (!bandwidth) {
  658.       return NaN;
  659.     }
  660.     const segmentDuration = segment.endTime - segment.startTime;
  661.     // Calculate file size in kilobits
  662.     const segmentSize = bandwidth * segmentDuration / 1000;
  663.     // Calculate time available to load file in seconds
  664.     const timeToLoad = (currentBufferLevel / playbackRate) / 1000;
  665.     // Calculate the exact bandwidth required
  666.     const minBandwidth = segmentSize / timeToLoad;
  667.     // Include a safety buffer
  668.     return minBandwidth * this.config_.rtpSafetyFactor;
  669.   }
  671.   /**
  672.    * Get the stream format
  673.    *
  674.    * @param {shaka.net.NetworkingEngine.AdvancedRequestType} type
  675.    *   The request's advanced type
  676.    * @return {(shaka.util.CmcdManager.StreamingFormat|undefined)}
  677.    * @private
  678.    */
  679.   getStreamFormat_(type) {
  680.     const AdvancedRequestType = shaka.net.NetworkingEngine.AdvancedRequestType;
  682.     switch (type) {
  683.       case AdvancedRequestType.MPD:
  684.         if (this.lowLatency_) {
  685.           return shaka.util.CmcdManager.StreamingFormat.LOW_LATENCY_DASH;
  686.         }
  687.         return shaka.util.CmcdManager.StreamingFormat.DASH;
  689.       case AdvancedRequestType.MASTER_PLAYLIST:
  690.       case AdvancedRequestType.MEDIA_PLAYLIST:
  691.         if (this.lowLatency_) {
  692.           return shaka.util.CmcdManager.StreamingFormat.LOW_LATENCY_HLS;
  693.         }
  694.         return shaka.util.CmcdManager.StreamingFormat.HLS;
  696.       case AdvancedRequestType.MSS:
  697.         return shaka.util.CmcdManager.StreamingFormat.SMOOTH;
  698.     }
  700.     return undefined;
  701.   }
  703.   /**
  704.    * Get the stream type
  705.    *
  706.    * @return {shaka.util.CmcdManager.StreamType}
  707.    * @private
  708.    */
  709.   getStreamType_() {
  710.     const isLive = this.playerInterface_.isLive();
  711.     if (isLive) {
  712.       return shaka.util.CmcdManager.StreamType.LIVE;
  713.     } else {
  714.       return shaka.util.CmcdManager.StreamType.VOD;
  715.     }
  716.   }
  718.   /**
  719.    * Get the highest bandwidth for a given type.
  720.    *
  721.    * @param {shaka.util.CmcdManager.ObjectType|undefined} type
  722.    * @return {number}
  723.    * @private
  724.    */
  725.   getTopBandwidth_(type) {
  726.     const variants = this.playerInterface_.getVariantTracks();
  727.     if (!variants.length) {
  728.       return NaN;
  729.     }
  731.     let top = variants[0];
  733.     for (const variant of variants) {
  734.       if (variant.type === 'variant' && variant.bandwidth > top.bandwidth) {
  735.         top = variant;
  736.       }
  737.     }
  739.     const ObjectType = shaka.util.CmcdManager.ObjectType;
  741.     switch (type) {
  742.       case ObjectType.VIDEO:
  743.         return top.videoBandwidth || NaN;
  745.       case ObjectType.AUDIO:
  746.         return top.audioBandwidth || NaN;
  748.       default:
  749.         return top.bandwidth;
  750.     }
  751.   }
  753.   /**
  754.    * Get CMCD data for a segment.
  755.    *
  756.    * @param {shaka.extern.RequestContext} context
  757.    *   The request context
  758.    * @param {?string} requestUri
  759.    * @return {!CmcdData}
  760.    * @private
  761.    */
  762.   getDataForSegment_(context, requestUri) {
  763.     const segment = context.segment;
  765.     let duration = 0;
  766.     if (segment) {
  767.       duration = segment.endTime - segment.startTime;
  768.     }
  770.     const data = {
  771.       d: duration * 1000,
  772.       st: this.getStreamType_(),
  773.     };
  775.     data.ot = this.getObjectType_(context);
  777.     const ObjectType = shaka.util.CmcdManager.ObjectType;
  778.     const isMedia = data.ot === ObjectType.VIDEO ||
  779.         data.ot === ObjectType.AUDIO ||
  780.         data.ot === ObjectType.MUXED ||
  781.         data.ot === ObjectType.TIMED_TEXT;
  783.     const stream = context.stream;
  784.     if (stream) {
  785.       const playbackRate = this.playerInterface_.getPlaybackRate();
  786.       if (isMedia) {
  787.         data.bl = this.getBufferLength_(stream.type);
  788.         if (data.ot !== ObjectType.TIMED_TEXT) {
  789.           const remainingBufferLength =
  790.               this.getRemainingBufferLength_(stream.type);
  791.           if (playbackRate) {
  792.             data.dl = remainingBufferLength / Math.abs(playbackRate);
  793.           } else {
  794.             data.dl = remainingBufferLength;
  795.           }
  796.         }
  797.       }
  799.       if (stream.bandwidth) {
  800.         data.br = stream.bandwidth / 1000;
  801.       }
  803.       if (stream.segmentIndex && segment) {
  804.         const reverse = playbackRate < 0;
  805.         const iterator = stream.segmentIndex.getIteratorForTime(
  806.             segment.endTime, /* allowNonIndependent= */ true, reverse);
  807.         if (iterator) {
  808.           const nextSegment = iterator.next().value;
  809.           if (nextSegment && nextSegment != segment) {
  810.             if (requestUri && !shaka.util.ArrayUtils.equal(
  811.                 segment.getUris(), nextSegment.getUris())) {
  812.               data.nor = this.urlToRelativePath_(
  813.                   nextSegment.getUris()[0], requestUri);
  814.             }
  815.             if ((nextSegment.startByte || nextSegment.endByte) &&
  816.                 (segment.startByte != nextSegment.startByte ||
  817.                 segment.endByte != nextSegment.endByte)) {
  818.               let range = nextSegment.startByte + '-';
  819.               if (nextSegment.endByte) {
  820.                 range += nextSegment.endByte;
  821.               }
  822.               data.nrr = range;
  823.             }
  824.           }
  825.         }
  826.         const rtp = this.calculateRtp_(stream, segment);
  827.         if (!isNaN(rtp)) {
  828.           data.rtp = rtp;
  829.         }
  830.       }
  831.     }
  833.     if (isMedia && data.ot !== ObjectType.TIMED_TEXT) {
  834.       data.tb = this.getTopBandwidth_(data.ot) / 1000;
  835.     }
  837.     return data;
  838.   }
  841.   /**
  842.    * Get generic CMCD data.
  843.    *
  844.    * @param {!CmcdData} data The data object
  845.    * @return {!CmcdData}
  846.    * @private
  847.    */
  848.   getGenericData_(data = {}) {
  849.     // Apply baseline data
  850.     Object.assign(data, this.createData_());
  852.     data.pr = this.playerInterface_.getPlaybackRate();
  854.     const isVideo = data.ot === shaka.util.CmcdManager.ObjectType.VIDEO ||
  855.         data.ot === shaka.util.CmcdManager.ObjectType.MUXED;
  857.     if (this.starved_ && isVideo) {
  858.       data.bs = true;
  859.       data.su = true;
  860.       this.starved_ = false;
  861.     }
  863.     if (data.su == null) {
  864.       data.su = this.buffering_;
  865.     }
  867.     if (data.v === shaka.util.CmcdManager.Version.VERSION_2) {
  868.       if (this.playerInterface_.isLive()) {
  869.         data.ltc = this.playerInterface_.getLiveLatency();
  870.       }
  872.       const msd = this.calculateMSD_();
  873.       if (msd != undefined) {
  874.         data.msd = msd;
  875.         this.msdSent_ = true;
  876.       }
  877.     }
  879.     return this.filterKeys_(data);
  880.   }
  882.   /**
  883.    * Serialize a CMCD data object according to the rules defined in the
  884.    * section 3.2 of
  885.    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
  886.    *
  887.    * @param {CmcdData} data The CMCD data object
  888.    * @return {string}
  889.    */
  890.   static serialize(data) {
  891.     const results = [];
  892.     const isValid = (value) =>
  893.       !Number.isNaN(value) && value != null && value !== '' && value !== false;
  894.     const toRounded = (value) => Math.round(value);
  895.     const toHundred = (value) => toRounded(value / 100) * 100;
  896.     const toUrlSafe = (value) => encodeURIComponent(value);
  897.     const formatters = {
  898.       br: toRounded,
  899.       d: toRounded,
  900.       bl: toHundred,
  901.       dl: toHundred,
  902.       mtp: toHundred,
  903.       nor: toUrlSafe,
  904.       rtp: toHundred,
  905.       tb: toRounded,
  906.     };
  908.     const keys = Object.keys(data || {}).sort();
  910.     for (const key of keys) {
  911.       let value = data[key];
  913.       // ignore invalid values
  914.       if (!isValid(value)) {
  915.         continue;
  916.       }
  918.       // Version should only be reported if not equal to 1.
  919.       if (key === 'v' && value === 1) {
  920.         continue;
  921.       }
  923.       // Playback rate should only be sent if not equal to 1.
  924.       if (key == 'pr' && value === 1) {
  925.         continue;
  926.       }
  928.       // Certain values require special formatting
  929.       const formatter = formatters[key];
  930.       if (formatter) {
  931.         value = formatter(value);
  932.       }
  934.       // Serialize the key/value pair
  935.       const type = typeof value;
  936.       let result;
  938.       if (type === 'string' && key !== 'ot' && key !== 'sf' && key !== 'st') {
  939.         result = `${key}=${JSON.stringify(value)}`;
  940.       } else if (type === 'boolean') {
  941.         result = key;
  942.       } else if (type === 'symbol') {
  943.         result = `${key}=${value.description}`;
  944.       } else {
  945.         result = `${key}=${value}`;
  946.       }
  948.       results.push(result);
  949.     }
  951.     return results.join(',');
  952.   }
  954.   /**
  955.    * Convert a CMCD data object to request headers according to the rules
  956.    * defined in the section 2.1 and 3.2 of
  957.    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
  958.    *
  959.    * @param {CmcdData} data The CMCD data object
  960.    * @return {!Object}
  961.    */
  962.   static toHeaders(data) {
  963.     const keys = Object.keys(data);
  964.     const headers = {};
  965.     const headerNames = ['Object', 'Request', 'Session', 'Status'];
  966.     const headerGroups = [{}, {}, {}, {}];
  967.     const headerMap = {
  968.       br: 0, d: 0, ot: 0, tb: 0,
  969.       bl: 1, dl: 1, mtp: 1, nor: 1, nrr: 1, su: 1, ltc: 1,
  970.       cid: 2, pr: 2, sf: 2, sid: 2, st: 2, v: 2, msd: 2,
  971.       bs: 3, rtp: 3,
  972.     };
  974.     for (const key of keys) {
  975.       // Unmapped fields are mapped to the Request header
  976.       const index = (headerMap[key] != null) ? headerMap[key] : 1;
  977.       headerGroups[index][key] = data[key];
  978.     }
  980.     for (let i = 0; i < headerGroups.length; i++) {
  981.       const value = shaka.util.CmcdManager.serialize(headerGroups[i]);
  982.       if (value) {
  983.         headers[`CMCD-${headerNames[i]}`] = value;
  984.       }
  985.     }
  987.     return headers;
  988.   }
  990.   /**
  991.    * Convert a CMCD data object to query args according to the rules
  992.    * defined in the section 2.2 and 3.2 of
  993.    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
  994.    *
  995.    * @param {CmcdData} data The CMCD data object
  996.    * @return {string}
  997.    */
  998.   static toQuery(data) {
  999.     return shaka.util.CmcdManager.serialize(data);
  1000.   }
  1002.   /**
  1003.    * Append query args to a uri.
  1004.    *
  1005.    * @param {string} uri
  1006.    * @param {string} query
  1007.    * @return {string}
  1008.    */
  1009.   static appendQueryToUri(uri, query) {
  1010.     if (!query) {
  1011.       return uri;
  1012.     }
  1014.     if (uri.includes('offline:')) {
  1015.       return uri;
  1016.     }
  1018.     const url = new goog.Uri(uri);
  1019.     url.getQueryData().set('CMCD', query);
  1020.     return url.toString();
  1021.   }
  1022. };
  1025. /**
  1026.  * @typedef {{
  1027.  *   getBandwidthEstimate: function():number,
  1028.  *   getBufferedInfo: function():shaka.extern.BufferedInfo,
  1029.  *   getCurrentTime: function():number,
  1030.  *   getPlaybackRate: function():number,
  1031.  *   getVariantTracks: function():Array<shaka.extern.Track>,
  1032.  *   isLive: function():boolean,
  1033.  *   getLiveLatency: function():number
  1034.  * }}
  1035.  *
  1036.  * @property {function():number} getBandwidthEstimate
  1037.  *   Get the estimated bandwidth in bits per second.
  1038.  * @property {function():shaka.extern.BufferedInfo} getBufferedInfo
  1039.  *   Get information about what the player has buffered.
  1040.  * @property {function():number} getCurrentTime
  1041.  *   Get the current time
  1042.  * @property {function():number} getPlaybackRate
  1043.  *   Get the playback rate
  1044.  * @property {function():Array<shaka.extern.Track>} getVariantTracks
  1045.  *   Get the variant tracks
  1046.  * @property {function():boolean} isLive
  1047.  *   Get if the player is playing live content.
  1048.  * @property {function():number} getLiveLatency
  1049.  *   Get latency in milliseconds between the live edge and what's currently
  1050.  *   playing.
  1051.  */
  1052. shaka.util.CmcdManager.PlayerInterface;
  1055. /**
  1056.  * @enum {string}
  1057.  */
  1058. shaka.util.CmcdManager.ObjectType = {
  1059.   MANIFEST: 'm',
  1060.   AUDIO: 'a',
  1061.   VIDEO: 'v',
  1062.   MUXED: 'av',
  1063.   INIT: 'i',
  1064.   CAPTION: 'c',
  1065.   TIMED_TEXT: 'tt',
  1066.   KEY: 'k',
  1067.   OTHER: 'o',
  1068. };
  1070. /**
  1071.  * @enum {number}
  1072.  */
  1073. shaka.util.CmcdManager.Version = {
  1074.   VERSION_1: 1,
  1075.   VERSION_2: 2,
  1076. };
  1078. /**
  1079.  * @enum {string}
  1080.  */
  1081. shaka.util.CmcdManager.StreamType = {
  1082.   VOD: 'v',
  1083.   LIVE: 'l',
  1084. };
  1087. /**
  1088.  * @enum {string}
  1089.  * @export
  1090.  */
  1091. shaka.util.CmcdManager.StreamingFormat = {
  1092.   DASH: 'd',
  1093.   LOW_LATENCY_DASH: 'ld',
  1094.   HLS: 'h',
  1095.   LOW_LATENCY_HLS: 'lh',
  1096.   SMOOTH: 's',
  1097.   OTHER: 'o',
  1098. };