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.     // apply baseline data
  423.     Object.assign(data, this.createData_());
  425.     data.pr = this.playerInterface_.getPlaybackRate();
  427.     const isVideo = data.ot === shaka.util.CmcdManager.ObjectType.VIDEO ||
  428.         data.ot === shaka.util.CmcdManager.ObjectType.MUXED;
  430.     if (this.starved_ && isVideo) {
  431.       data.bs = true;
  432.       data.su = true;
  433.       this.starved_ = false;
  434.     }
  436.     if (data.su == null) {
  437.       data.su = this.buffering_;
  438.     }
  440.     if (data.v === shaka.util.CmcdManager.Version.VERSION_2) {
  441.       if (this.playerInterface_.isLive()) {
  442.         data.ltc = this.playerInterface_.getLiveLatency();
  443.       }
  445.       const msd = this.calculateMSD_();
  446.       if (msd != undefined) {
  447.         data.msd = msd;
  448.         this.msdSent_ = true;
  449.       }
  450.     }
  452.     const output = this.filterKeys_(data);
  454.     if (useHeaders) {
  455.       const headers = shaka.util.CmcdManager.toHeaders(output);
  456.       if (!Object.keys(headers).length) {
  457.         return;
  458.       }
  460.       Object.assign(request.headers, headers);
  461.     } else {
  462.       const query = shaka.util.CmcdManager.toQuery(output);
  463.       if (!query) {
  464.         return;
  465.       }
  467.       request.uris = request.uris.map((uri) => {
  468.         return shaka.util.CmcdManager.appendQueryToUri(uri, query);
  469.       });
  470.     }
  471.   }
  473.   /**
  474.    * Filter the CMCD data object to include only the keys specified in the
  475.    * configuration.
  476.    *
  477.    * @param {CmcdData} data
  478.    * @return {CmcdData}
  479.    * @private
  480.    */
  481.   filterKeys_(data) {
  482.     const includeKeys = this.config_.includeKeys;
  484.     if (!includeKeys.length) {
  485.       return data;
  486.     }
  488.     return Object.keys(data).reduce((acc, key) => {
  489.       if (includeKeys.includes(key)) {
  490.         acc[key] = data[key];
  491.       }
  492.       return acc;
  493.     }, {});
  494.   }
  496.   /**
  497.    * The CMCD object type.
  498.    *
  499.    * @param {shaka.extern.RequestContext} context
  500.    *   The request context
  501.    * @return {shaka.util.CmcdManager.ObjectType|undefined}
  502.    * @private
  503.    */
  504.   getObjectType_(context) {
  505.     if (context.type ===
  506.         shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT) {
  507.       return shaka.util.CmcdManager.ObjectType.INIT;
  508.     }
  510.     const stream = context.stream;
  512.     if (!stream) {
  513.       return undefined;
  514.     }
  516.     const type = stream.type;
  518.     if (type == 'video') {
  519.       if (stream.codecs && stream.codecs.includes(',')) {
  520.         return shaka.util.CmcdManager.ObjectType.MUXED;
  521.       }
  522.       return shaka.util.CmcdManager.ObjectType.VIDEO;
  523.     }
  525.     if (type == 'audio') {
  526.       return shaka.util.CmcdManager.ObjectType.AUDIO;
  527.     }
  529.     if (type == 'text') {
  530.       if (stream.mimeType === 'application/mp4') {
  531.         return shaka.util.CmcdManager.ObjectType.TIMED_TEXT;
  532.       }
  533.       return shaka.util.CmcdManager.ObjectType.CAPTION;
  534.     }
  536.     return undefined;
  537.   }
  539.   /**
  540.    * The CMCD object type from mimeType.
  541.    *
  542.    * @param {!string} mimeType
  543.    * @return {(shaka.util.CmcdManager.ObjectType|undefined)}
  544.    * @private
  545.    */
  546.   getObjectTypeFromMimeType_(mimeType) {
  547.     switch (mimeType.toLowerCase()) {
  548.       case 'audio/mp4':
  549.       case 'audio/webm':
  550.       case 'audio/ogg':
  551.       case 'audio/mpeg':
  552.       case 'audio/aac':
  553.       case 'audio/flac':
  554.       case 'audio/wav':
  555.         return shaka.util.CmcdManager.ObjectType.AUDIO;
  557.       case 'video/webm':
  558.       case 'video/mp4':
  559.       case 'video/mpeg':
  560.       case 'video/mp2t':
  561.         return shaka.util.CmcdManager.ObjectType.MUXED;
  563.       case 'application/x-mpegurl':
  564.       case 'application/vnd.apple.mpegurl':
  565.       case 'application/dash+xml':
  566.       case 'video/vnd.mpeg.dash.mpd':
  567.       case 'application/vnd.ms-sstr+xml':
  568.         return shaka.util.CmcdManager.ObjectType.MANIFEST;
  570.       default:
  571.         return undefined;
  572.     }
  573.   }
  575.   /**
  576.    * Get the buffer length for a media type in milliseconds
  577.    *
  578.    * @param {string} type
  579.    * @return {number}
  580.    * @private
  581.    */
  582.   getBufferLength_(type) {
  583.     const ranges = this.playerInterface_.getBufferedInfo()[type];
  585.     if (!ranges.length) {
  586.       return NaN;
  587.     }
  589.     const start = this.playerInterface_.getCurrentTime();
  590.     const range = ranges.find((r) => r.start <= start && r.end >= start);
  592.     if (!range) {
  593.       return NaN;
  594.     }
  596.     return (range.end - start) * 1000;
  597.   }
  599.   /**
  600.    * Get the remaining buffer length for a media type in milliseconds
  601.    *
  602.    * @param {string} type
  603.    * @return {number}
  604.    * @private
  605.    */
  606.   getRemainingBufferLength_(type) {
  607.     const ranges = this.playerInterface_.getBufferedInfo()[type];
  609.     if (!ranges.length) {
  610.       return 0;
  611.     }
  613.     const start = this.playerInterface_.getCurrentTime();
  614.     const range = ranges.find((r) => r.start <= start && r.end >= start);
  616.     if (!range) {
  617.       return 0;
  618.     }
  620.     return (range.end - start) * 1000;
  621.   }
  623.   /**
  624.    * Constructs a relative path from a URL
  625.    *
  626.    * @param {string} url
  627.    * @param {string} base
  628.    * @return {string}
  629.    * @private
  630.    */
  631.   urlToRelativePath_(url, base) {
  632.     const to = new URL(url);
  633.     const from = new URL(base);
  635.     if (to.origin !== from.origin) {
  636.       return url;
  637.     }
  639.     const toPath = to.pathname.split('/').slice(1);
  640.     const fromPath = from.pathname.split('/').slice(1, -1);
  642.     // remove common parents
  643.     while (toPath[0] === fromPath[0]) {
  644.       toPath.shift();
  645.       fromPath.shift();
  646.     }
  648.     // add back paths
  649.     while (fromPath.length) {
  650.       fromPath.shift();
  651.       toPath.unshift('..');
  652.     }
  654.     return toPath.join('/');
  655.   }
  657.   /**
  658.    * Calculate measured start delay
  659.    *
  660.    * @return {number|undefined}
  661.    * @private
  662.    */
  663.   calculateMSD_() {
  664.     if (!this.msdSent_ &&
  665.         this.playbackPlayingTime_ &&
  666.         this.playbackPlayTime_) {
  667.       const startTime = this.startTimeOfLoad_ || this.playbackPlayTime_;
  668.       return this.playbackPlayingTime_ - startTime;
  669.     }
  670.     return undefined;
  671.   }
  674.   /**
  675.    * Calculate requested maximum throughput
  676.    *
  677.    * @param {shaka.extern.Stream} stream
  678.    * @param {shaka.media.SegmentReference} segment
  679.    * @return {number}
  680.    * @private
  681.    */
  682.   calculateRtp_(stream, segment) {
  683.     const playbackRate = this.playerInterface_.getPlaybackRate() || 1;
  684.     const currentBufferLevel =
  685.         this.getRemainingBufferLength_(stream.type) || 500;
  686.     const bandwidth = stream.bandwidth;
  687.     if (!bandwidth) {
  688.       return NaN;
  689.     }
  690.     const segmentDuration = segment.endTime - segment.startTime;
  691.     // Calculate file size in kilobits
  692.     const segmentSize = bandwidth * segmentDuration / 1000;
  693.     // Calculate time available to load file in seconds
  694.     const timeToLoad = (currentBufferLevel / playbackRate) / 1000;
  695.     // Calculate the exact bandwidth required
  696.     const minBandwidth = segmentSize / timeToLoad;
  697.     // Include a safety buffer
  698.     return minBandwidth * this.config_.rtpSafetyFactor;
  699.   }
  701.   /**
  702.    * Get the stream format
  703.    *
  704.    * @param {shaka.net.NetworkingEngine.AdvancedRequestType} type
  705.    *   The request's advanced type
  706.    * @return {(shaka.util.CmcdManager.StreamingFormat|undefined)}
  707.    * @private
  708.    */
  709.   getStreamFormat_(type) {
  710.     const AdvancedRequestType = shaka.net.NetworkingEngine.AdvancedRequestType;
  712.     switch (type) {
  713.       case AdvancedRequestType.MPD:
  714.         if (this.lowLatency_) {
  715.           return shaka.util.CmcdManager.StreamingFormat.LOW_LATENCY_DASH;
  716.         }
  717.         return shaka.util.CmcdManager.StreamingFormat.DASH;
  719.       case AdvancedRequestType.MASTER_PLAYLIST:
  720.       case AdvancedRequestType.MEDIA_PLAYLIST:
  721.         if (this.lowLatency_) {
  722.           return shaka.util.CmcdManager.StreamingFormat.LOW_LATENCY_HLS;
  723.         }
  724.         return shaka.util.CmcdManager.StreamingFormat.HLS;
  726.       case AdvancedRequestType.MSS:
  727.         return shaka.util.CmcdManager.StreamingFormat.SMOOTH;
  728.     }
  730.     return undefined;
  731.   }
  733.   /**
  734.    * Get the stream type
  735.    *
  736.    * @return {shaka.util.CmcdManager.StreamType}
  737.    * @private
  738.    */
  739.   getStreamType_() {
  740.     const isLive = this.playerInterface_.isLive();
  741.     if (isLive) {
  742.       return shaka.util.CmcdManager.StreamType.LIVE;
  743.     } else {
  744.       return shaka.util.CmcdManager.StreamType.VOD;
  745.     }
  746.   }
  748.   /**
  749.    * Get the highest bandwidth for a given type.
  750.    *
  751.    * @param {shaka.util.CmcdManager.ObjectType|undefined} type
  752.    * @return {number}
  753.    * @private
  754.    */
  755.   getTopBandwidth_(type) {
  756.     const variants = this.playerInterface_.getVariantTracks();
  757.     if (!variants.length) {
  758.       return NaN;
  759.     }
  761.     let top = variants[0];
  763.     for (const variant of variants) {
  764.       if (variant.type === 'variant' && variant.bandwidth > top.bandwidth) {
  765.         top = variant;
  766.       }
  767.     }
  769.     const ObjectType = shaka.util.CmcdManager.ObjectType;
  771.     switch (type) {
  772.       case ObjectType.VIDEO:
  773.         return top.videoBandwidth || NaN;
  775.       case ObjectType.AUDIO:
  776.         return top.audioBandwidth || NaN;
  778.       default:
  779.         return top.bandwidth;
  780.     }
  781.   }
  783.   /**
  784.    * Get CMCD data for a segment.
  785.    *
  786.    * @param {shaka.extern.RequestContext} context
  787.    *   The request context
  788.    * @param {?string} requestUri
  789.    * @return {!CmcdData}
  790.    * @private
  791.    */
  792.   getDataForSegment_(context, requestUri) {
  793.     const segment = context.segment;
  795.     let duration = 0;
  796.     if (segment) {
  797.       duration = segment.endTime - segment.startTime;
  798.     }
  800.     const data = {
  801.       d: duration * 1000,
  802.       st: this.getStreamType_(),
  803.     };
  805.     data.ot = this.getObjectType_(context);
  807.     const ObjectType = shaka.util.CmcdManager.ObjectType;
  808.     const isMedia = data.ot === ObjectType.VIDEO ||
  809.         data.ot === ObjectType.AUDIO ||
  810.         data.ot === ObjectType.MUXED ||
  811.         data.ot === ObjectType.TIMED_TEXT;
  813.     const stream = context.stream;
  814.     if (stream) {
  815.       const playbackRate = this.playerInterface_.getPlaybackRate();
  816.       if (isMedia) {
  817.         data.bl = this.getBufferLength_(stream.type);
  818.         if (data.ot !== ObjectType.TIMED_TEXT) {
  819.           const remainingBufferLength =
  820.               this.getRemainingBufferLength_(stream.type);
  821.           if (playbackRate) {
  822.             data.dl = remainingBufferLength / Math.abs(playbackRate);
  823.           } else {
  824.             data.dl = remainingBufferLength;
  825.           }
  826.         }
  827.       }
  829.       if (stream.bandwidth) {
  830.         data.br = stream.bandwidth / 1000;
  831.       }
  833.       if (stream.segmentIndex && segment) {
  834.         const reverse = playbackRate < 0;
  835.         const iterator = stream.segmentIndex.getIteratorForTime(
  836.             segment.endTime, /* allowNonIndependent= */ true, reverse);
  837.         if (iterator) {
  838.           const nextSegment = iterator.next().value;
  839.           if (nextSegment && nextSegment != segment) {
  840.             if (requestUri && !shaka.util.ArrayUtils.equal(
  841.                 segment.getUris(), nextSegment.getUris())) {
  842.               data.nor = this.urlToRelativePath_(
  843.                   nextSegment.getUris()[0], requestUri);
  844.             }
  845.             if ((nextSegment.startByte || nextSegment.endByte) &&
  846.                 (segment.startByte != nextSegment.startByte ||
  847.                 segment.endByte != nextSegment.endByte)) {
  848.               let range = nextSegment.startByte + '-';
  849.               if (nextSegment.endByte) {
  850.                 range += nextSegment.endByte;
  851.               }
  852.               data.nrr = range;
  853.             }
  854.           }
  855.         }
  856.         const rtp = this.calculateRtp_(stream, segment);
  857.         if (!isNaN(rtp)) {
  858.           data.rtp = rtp;
  859.         }
  860.       }
  861.     }
  863.     if (isMedia && data.ot !== ObjectType.TIMED_TEXT) {
  864.       data.tb = this.getTopBandwidth_(data.ot) / 1000;
  865.     }
  867.     return data;
  868.   }
  870.   /**
  871.    * Serialize a CMCD data object according to the rules defined in the
  872.    * section 3.2 of
  873.    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
  874.    *
  875.    * @param {CmcdData} data The CMCD data object
  876.    * @return {string}
  877.    */
  878.   static serialize(data) {
  879.     const results = [];
  880.     const isValid = (value) =>
  881.       !Number.isNaN(value) && value != null && value !== '' && value !== false;
  882.     const toRounded = (value) => Math.round(value);
  883.     const toHundred = (value) => toRounded(value / 100) * 100;
  884.     const toUrlSafe = (value) => encodeURIComponent(value);
  885.     const formatters = {
  886.       br: toRounded,
  887.       d: toRounded,
  888.       bl: toHundred,
  889.       dl: toHundred,
  890.       mtp: toHundred,
  891.       nor: toUrlSafe,
  892.       rtp: toHundred,
  893.       tb: toRounded,
  894.     };
  896.     const keys = Object.keys(data || {}).sort();
  898.     for (const key of keys) {
  899.       let value = data[key];
  901.       // ignore invalid values
  902.       if (!isValid(value)) {
  903.         continue;
  904.       }
  906.       // Version should only be reported if not equal to 1.
  907.       if (key === 'v' && value === 1) {
  908.         continue;
  909.       }
  911.       // Playback rate should only be sent if not equal to 1.
  912.       if (key == 'pr' && value === 1) {
  913.         continue;
  914.       }
  916.       // Certain values require special formatting
  917.       const formatter = formatters[key];
  918.       if (formatter) {
  919.         value = formatter(value);
  920.       }
  922.       // Serialize the key/value pair
  923.       const type = typeof value;
  924.       let result;
  926.       if (type === 'string' && key !== 'ot' && key !== 'sf' && key !== 'st') {
  927.         result = `${key}=${JSON.stringify(value)}`;
  928.       } else if (type === 'boolean') {
  929.         result = key;
  930.       } else if (type === 'symbol') {
  931.         result = `${key}=${value.description}`;
  932.       } else {
  933.         result = `${key}=${value}`;
  934.       }
  936.       results.push(result);
  937.     }
  939.     return results.join(',');
  940.   }
  942.   /**
  943.    * Convert a CMCD data object to request headers according to the rules
  944.    * defined in the section 2.1 and 3.2 of
  945.    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
  946.    *
  947.    * @param {CmcdData} data The CMCD data object
  948.    * @return {!Object}
  949.    */
  950.   static toHeaders(data) {
  951.     const keys = Object.keys(data);
  952.     const headers = {};
  953.     const headerNames = ['Object', 'Request', 'Session', 'Status'];
  954.     const headerGroups = [{}, {}, {}, {}];
  955.     const headerMap = {
  956.       br: 0, d: 0, ot: 0, tb: 0,
  957.       bl: 1, dl: 1, mtp: 1, nor: 1, nrr: 1, su: 1, ltc: 1,
  958.       cid: 2, pr: 2, sf: 2, sid: 2, st: 2, v: 2, msd: 2,
  959.       bs: 3, rtp: 3,
  960.     };
  962.     for (const key of keys) {
  963.       // Unmapped fields are mapped to the Request header
  964.       const index = (headerMap[key] != null) ? headerMap[key] : 1;
  965.       headerGroups[index][key] = data[key];
  966.     }
  968.     for (let i = 0; i < headerGroups.length; i++) {
  969.       const value = shaka.util.CmcdManager.serialize(headerGroups[i]);
  970.       if (value) {
  971.         headers[`CMCD-${headerNames[i]}`] = value;
  972.       }
  973.     }
  975.     return headers;
  976.   }
  978.   /**
  979.    * Convert a CMCD data object to query args according to the rules
  980.    * defined in the section 2.2 and 3.2 of
  981.    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
  982.    *
  983.    * @param {CmcdData} data The CMCD data object
  984.    * @return {string}
  985.    */
  986.   static toQuery(data) {
  987.     return shaka.util.CmcdManager.serialize(data);
  988.   }
  990.   /**
  991.    * Append query args to a uri.
  992.    *
  993.    * @param {string} uri
  994.    * @param {string} query
  995.    * @return {string}
  996.    */
  997.   static appendQueryToUri(uri, query) {
  998.     if (!query) {
  999.       return uri;
  1000.     }
  1002.     if (uri.includes('offline:')) {
  1003.       return uri;
  1004.     }
  1006.     const url = new goog.Uri(uri);
  1007.     url.getQueryData().set('CMCD', query);
  1008.     return url.toString();
  1009.   }
  1010. };
  1013. /**
  1014.  * @typedef {{
  1015.  *   getBandwidthEstimate: function():number,
  1016.  *   getBufferedInfo: function():shaka.extern.BufferedInfo,
  1017.  *   getCurrentTime: function():number,
  1018.  *   getPlaybackRate: function():number,
  1019.  *   getVariantTracks: function():Array<shaka.extern.Track>,
  1020.  *   isLive: function():boolean,
  1021.  *   getLiveLatency: function():number
  1022.  * }}
  1023.  *
  1024.  * @property {function():number} getBandwidthEstimate
  1025.  *   Get the estimated bandwidth in bits per second.
  1026.  * @property {function():shaka.extern.BufferedInfo} getBufferedInfo
  1027.  *   Get information about what the player has buffered.
  1028.  * @property {function():number} getCurrentTime
  1029.  *   Get the current time
  1030.  * @property {function():number} getPlaybackRate
  1031.  *   Get the playback rate
  1032.  * @property {function():Array<shaka.extern.Track>} getVariantTracks
  1033.  *   Get the variant tracks
  1034.  * @property {function():boolean} isLive
  1035.  *   Get if the player is playing live content.
  1036.  * @property {function():number} getLiveLatency
  1037.  *   Get latency in milliseconds between the live edge and what's currently
  1038.  *   playing.
  1039.  */
  1040. shaka.util.CmcdManager.PlayerInterface;
  1043. /**
  1044.  * @enum {string}
  1045.  */
  1046. shaka.util.CmcdManager.ObjectType = {
  1047.   MANIFEST: 'm',
  1048.   AUDIO: 'a',
  1049.   VIDEO: 'v',
  1050.   MUXED: 'av',
  1051.   INIT: 'i',
  1052.   CAPTION: 'c',
  1053.   TIMED_TEXT: 'tt',
  1054.   KEY: 'k',
  1055.   OTHER: 'o',
  1056. };
  1058. /**
  1059.  * @enum {number}
  1060.  */
  1061. shaka.util.CmcdManager.Version = {
  1062.   VERSION_1: 1,
  1063.   VERSION_2: 2,
  1064. };
  1066. /**
  1067.  * @enum {string}
  1068.  */
  1069. shaka.util.CmcdManager.StreamType = {
  1070.   VOD: 'v',
  1071.   LIVE: 'l',
  1072. };
  1075. /**
  1076.  * @enum {string}
  1077.  * @export
  1078.  */
  1079. shaka.util.CmcdManager.StreamingFormat = {
  1080.   DASH: 'd',
  1081.   LOW_LATENCY_DASH: 'ld',
  1082.   HLS: 'h',
  1083.   LOW_LATENCY_HLS: 'lh',
  1084.   SMOOTH: 's',
  1085.   OTHER: 'o',
  1086. };