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');
  14. goog.requireType('shaka.media.SegmentReference');
  16. /**
  17.  * @summary
  18.  * A CmcdManager maintains CMCD state as well as a collection of utility
  19.  * functions.
  20.  */
  21. shaka.util.CmcdManager = class {
  22.   /**
  23.    * @param {shaka.util.CmcdManager.PlayerInterface} playerInterface
  24.    * @param {shaka.extern.CmcdConfiguration} config
  25.    */
  26.   constructor(playerInterface, config) {
  27.     /** @private {shaka.util.CmcdManager.PlayerInterface} */
  28.     this.playerInterface_ = playerInterface;
  30.     /** @private {?shaka.extern.CmcdConfiguration} */
  31.     this.config_ = config;
  33.     /**
  34.      * Streaming format
  35.      *
  36.      * @private {(shaka.util.CmcdManager.StreamingFormat|undefined)}
  37.      */
  38.     this.sf_ = undefined;
  40.     /**
  41.      * @private {boolean}
  42.      */
  43.     this.playbackStarted_ = false;
  45.     /**
  46.     * @private {boolean}
  47.     */
  48.     this.buffering_ = true;
  50.     /**
  51.      * @private {boolean}
  52.      */
  53.     this.starved_ = false;
  54.   }
  56.   /**
  57.    * Called by the Player to provide an updated configuration any time it
  58.    * changes.
  59.    *
  60.    * @param {shaka.extern.CmcdConfiguration} config
  61.    */
  62.   configure(config) {
  63.     this.config_ = config;
  64.   }
  67.   /**
  68.    * Resets the CmcdManager.
  69.    */
  70.   reset() {
  71.     this.playbackStarted_ = false;
  72.     this.buffering_ = true;
  73.     this.starved_ = false;
  74.   }
  76.   /**
  77.    * Set the buffering state
  78.    *
  79.    * @param {boolean} buffering
  80.    */
  81.   setBuffering(buffering) {
  82.     if (!buffering && !this.playbackStarted_) {
  83.       this.playbackStarted_ = true;
  84.     }
  86.     if (this.playbackStarted_ && buffering) {
  87.       this.starved_ = true;
  88.     }
  90.     this.buffering_ = buffering;
  91.   }
  93.   /**
  94.    * Apply CMCD data to a request.
  95.    *
  96.    * @param {!shaka.net.NetworkingEngine.RequestType} type
  97.    *   The request type
  98.    * @param {!shaka.extern.Request} request
  99.    *   The request to apply CMCD data to
  100.    * @param {shaka.extern.RequestContext=} context
  101.    *   The request context
  102.    */
  103.   applyData(type, request, context = {}) {
  104.     if (!this.config_.enabled) {
  105.       return;
  106.     }
  108.     if (request.method === 'HEAD') {
  109.       this.apply_(request);
  110.       return;
  111.     }
  113.     const RequestType = shaka.net.NetworkingEngine.RequestType;
  114.     const ObjectType = shaka.util.CmcdManager.ObjectType;
  116.     switch (type) {
  117.       case RequestType.MANIFEST:
  118.         this.applyManifestData(request, context);
  119.         break;
  121.       case RequestType.SEGMENT:
  122.         this.applySegmentData(request, context);
  123.         break;
  125.       case RequestType.LICENSE:
  126.       case RequestType.SERVER_CERTIFICATE:
  127.       case RequestType.KEY:
  128.         this.apply_(request, {ot: ObjectType.KEY});
  129.         break;
  131.       case RequestType.TIMING:
  132.         this.apply_(request, {ot: ObjectType.OTHER});
  133.         break;
  134.     }
  135.   }
  137.   /**
  138.    * Apply CMCD data to a manifest request.
  139.    *
  140.    * @param {!shaka.extern.Request} request
  141.    *   The request to apply CMCD data to
  142.    * @param {shaka.extern.RequestContext} context
  143.    *   The request context
  144.    */
  145.   applyManifestData(request, context) {
  146.     try {
  147.       if (!this.config_.enabled) {
  148.         return;
  149.       }
  151.       if (context.type) {
  152.         this.sf_ = this.getStreamFormat_(context.type);
  153.       }
  155.       this.apply_(request, {
  156.         ot: shaka.util.CmcdManager.ObjectType.MANIFEST,
  157.         su: !this.playbackStarted_,
  158.       });
  159.     } catch (error) {
  160.       shaka.log.warnOnce('CMCD_MANIFEST_ERROR',
  161.           'Could not generate manifest CMCD data.', error);
  162.     }
  163.   }
  165.   /**
  166.    * Apply CMCD data to a segment request
  167.    *
  168.    * @param {!shaka.extern.Request} request
  169.    * @param {shaka.extern.RequestContext} context
  170.    *   The request context
  171.    */
  172.   applySegmentData(request, context) {
  173.     try {
  174.       if (!this.config_.enabled) {
  175.         return;
  176.       }
  178.       const segment = context.segment;
  180.       let duration = 0;
  181.       if (segment) {
  182.         duration = segment.endTime - segment.startTime;
  183.       }
  185.       const data = {
  186.         d: duration * 1000,
  187.         st: this.getStreamType_(),
  188.       };
  190.       data.ot = this.getObjectType_(context);
  192.       const ObjectType = shaka.util.CmcdManager.ObjectType;
  193.       const isMedia = data.ot === ObjectType.VIDEO ||
  194.           data.ot === ObjectType.AUDIO ||
  195.           data.ot === ObjectType.MUXED ||
  196.           data.ot === ObjectType.TIMED_TEXT;
  198.       const stream = context.stream;
  199.       if (stream) {
  200.         const playbackRate = this.playerInterface_.getPlaybackRate();
  201.         if (isMedia) {
  202.           data.bl = this.getBufferLength_(stream.type);
  203.           if (data.ot !== ObjectType.TIMED_TEXT) {
  204.             const remainingBufferLength =
  205.                 this.getRemainingBufferLength_(stream.type);
  206.             if (playbackRate) {
  207.               data.dl = remainingBufferLength / Math.abs(playbackRate);
  208.             } else {
  209.               data.dl = remainingBufferLength;
  210.             }
  211.           }
  212.         }
  214.         if (stream.bandwidth) {
  215.           data.br = stream.bandwidth / 1000;
  216.         }
  218.         if (stream.segmentIndex && segment) {
  219.           const reverse = playbackRate < 0;
  220.           const iterator = stream.segmentIndex.getIteratorForTime(
  221.               segment.endTime, /* allowNonIndepedent= */ true, reverse);
  222.           if (iterator) {
  223.             const nextSegment = iterator.next().value;
  224.             if (nextSegment && nextSegment != segment) {
  225.               if (!shaka.util.ArrayUtils.equal(
  226.                   segment.getUris(), nextSegment.getUris())) {
  227.                 data.nor = this.urlToRelativePath_(
  228.                     nextSegment.getUris()[0], request.uris[0]);
  229.               }
  230.               if ((nextSegment.startByte || nextSegment.endByte) &&
  231.                   (segment.startByte != nextSegment.startByte ||
  232.                   segment.endByte != nextSegment.endByte)) {
  233.                 let range = nextSegment.startByte + '-';
  234.                 if (nextSegment.endByte) {
  235.                   range += nextSegment.endByte;
  236.                 }
  237.                 data.nrr = range;
  238.               }
  239.             }
  240.           }
  241.           const rtp = this.calculateRtp_(stream, segment);
  242.           if (!isNaN(rtp)) {
  243.             data.rtp = rtp;
  244.           }
  245.         }
  246.       }
  248.       if (isMedia && data.ot !== ObjectType.TIMED_TEXT) {
  249.         data.tb = this.getTopBandwidth_(data.ot) / 1000;
  250.       }
  252.       this.apply_(request, data);
  253.     } catch (error) {
  254.       shaka.log.warnOnce('CMCD_SEGMENT_ERROR',
  255.           'Could not generate segment CMCD data.', error);
  256.     }
  257.   }
  259.   /**
  260.    * Apply CMCD data to a text request
  261.    *
  262.    * @param {!shaka.extern.Request} request
  263.    */
  264.   applyTextData(request) {
  265.     try {
  266.       if (!this.config_.enabled) {
  267.         return;
  268.       }
  270.       this.apply_(request, {
  271.         ot: shaka.util.CmcdManager.ObjectType.CAPTION,
  272.         su: true,
  273.       });
  274.     } catch (error) {
  275.       shaka.log.warnOnce('CMCD_TEXT_ERROR',
  276.           'Could not generate text CMCD data.', error);
  277.     }
  278.   }
  280.   /**
  281.    * Apply CMCD data to streams loaded via src=.
  282.    *
  283.    * @param {string} uri
  284.    * @param {string} mimeType
  285.    * @return {string}
  286.    */
  287.   appendSrcData(uri, mimeType) {
  288.     try {
  289.       if (!this.config_.enabled) {
  290.         return uri;
  291.       }
  293.       const data = this.createData_();
  294.       data.ot = this.getObjectTypeFromMimeType_(mimeType);
  295.       data.su = true;
  297.       const query = shaka.util.CmcdManager.toQuery(data);
  299.       return shaka.util.CmcdManager.appendQueryToUri(uri, query);
  300.     } catch (error) {
  301.       shaka.log.warnOnce('CMCD_SRC_ERROR',
  302.           'Could not generate src CMCD data.', error);
  303.       return uri;
  304.     }
  305.   }
  307.   /**
  308.    * Apply CMCD data to side car text track uri.
  309.    *
  310.    * @param {string} uri
  311.    * @return {string}
  312.    */
  313.   appendTextTrackData(uri) {
  314.     try {
  315.       if (!this.config_.enabled) {
  316.         return uri;
  317.       }
  319.       const data = this.createData_();
  320.       data.ot = shaka.util.CmcdManager.ObjectType.CAPTION;
  321.       data.su = true;
  323.       const query = shaka.util.CmcdManager.toQuery(data);
  325.       return shaka.util.CmcdManager.appendQueryToUri(uri, query);
  326.     } catch (error) {
  327.       shaka.log.warnOnce('CMCD_TEXT_TRACK_ERROR',
  328.           'Could not generate text track CMCD data.', error);
  329.       return uri;
  330.     }
  331.   }
  333.   /**
  334.    * Create baseline CMCD data
  335.    *
  336.    * @return {CmcdData}
  337.    * @private
  338.    */
  339.   createData_() {
  340.     if (!this.config_.sessionId) {
  341.       this.config_.sessionId = window.crypto.randomUUID();
  342.     }
  343.     return {
  344.       v: shaka.util.CmcdManager.Version,
  345.       sf: this.sf_,
  346.       sid: this.config_.sessionId,
  347.       cid: this.config_.contentId,
  348.       mtp: this.playerInterface_.getBandwidthEstimate() / 1000,
  349.     };
  350.   }
  352.   /**
  353.    * Apply CMCD data to a request.
  354.    *
  355.    * @param {!shaka.extern.Request} request The request to apply CMCD data to
  356.    * @param {!CmcdData} data The data object
  357.    * @param {boolean} useHeaders Send data via request headers
  358.    * @private
  359.    */
  360.   apply_(request, data = {}, useHeaders = this.config_.useHeaders) {
  361.     if (!this.config_.enabled) {
  362.       return;
  363.     }
  365.     // apply baseline data
  366.     Object.assign(data, this.createData_());
  368.     data.pr = this.playerInterface_.getPlaybackRate();
  370.     const isVideo = data.ot === shaka.util.CmcdManager.ObjectType.VIDEO ||
  371.         data.ot === shaka.util.CmcdManager.ObjectType.MUXED;
  373.     if (this.starved_ && isVideo) {
  374.       data.bs = true;
  375.       data.su = true;
  376.       this.starved_ = false;
  377.     }
  379.     if (data.su == null) {
  380.       data.su = this.buffering_;
  381.     }
  383.     const output = this.filterKeys_(data);
  385.     if (useHeaders) {
  386.       const headers = shaka.util.CmcdManager.toHeaders(output);
  387.       if (!Object.keys(headers).length) {
  388.         return;
  389.       }
  391.       Object.assign(request.headers, headers);
  392.     } else {
  393.       const query = shaka.util.CmcdManager.toQuery(output);
  394.       if (!query) {
  395.         return;
  396.       }
  398.       request.uris = request.uris.map((uri) => {
  399.         return shaka.util.CmcdManager.appendQueryToUri(uri, query);
  400.       });
  401.     }
  402.   }
  404.   /**
  405.    * Filter the CMCD data object to include only the keys specified in the
  406.    * configuration.
  407.    *
  408.    * @param {CmcdData} data
  409.    * @return {CmcdData}
  410.    * @private
  411.    */
  412.   filterKeys_(data) {
  413.     const includeKeys = this.config_.includeKeys;
  415.     if (!includeKeys.length) {
  416.       return data;
  417.     }
  419.     return Object.keys(data).reduce((acc, key) => {
  420.       if (includeKeys.includes(key)) {
  421.         acc[key] = data[key];
  422.       }
  423.       return acc;
  424.     }, {});
  425.   }
  427.   /**
  428.    * The CMCD object type.
  429.    *
  430.    * @param {shaka.extern.RequestContext} context
  431.    *   The request context
  432.    * @private
  433.    */
  434.   getObjectType_(context) {
  435.     if (context.type ===
  436.         shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT) {
  437.       return shaka.util.CmcdManager.ObjectType.INIT;
  438.     }
  440.     const stream = context.stream;
  442.     if (!stream) {
  443.       return undefined;
  444.     }
  446.     const type = stream.type;
  448.     if (type == 'video') {
  449.       if (stream.codecs && stream.codecs.includes(',')) {
  450.         return shaka.util.CmcdManager.ObjectType.MUXED;
  451.       }
  452.       return shaka.util.CmcdManager.ObjectType.VIDEO;
  453.     }
  455.     if (type == 'audio') {
  456.       return shaka.util.CmcdManager.ObjectType.AUDIO;
  457.     }
  459.     if (type == 'text') {
  460.       if (stream.mimeType === 'application/mp4') {
  461.         return shaka.util.CmcdManager.ObjectType.TIMED_TEXT;
  462.       }
  463.       return shaka.util.CmcdManager.ObjectType.CAPTION;
  464.     }
  466.     return undefined;
  467.   }
  469.   /**
  470.    * The CMCD object type from mimeType.
  471.    *
  472.    * @param {!string} mimeType
  473.    * @return {(shaka.util.CmcdManager.ObjectType|undefined)}
  474.    * @private
  475.    */
  476.   getObjectTypeFromMimeType_(mimeType) {
  477.     switch (mimeType.toLowerCase()) {
  478.       case 'audio/mp4':
  479.       case 'audio/webm':
  480.       case 'audio/ogg':
  481.       case 'audio/mpeg':
  482.       case 'audio/aac':
  483.       case 'audio/flac':
  484.       case 'audio/wav':
  485.         return shaka.util.CmcdManager.ObjectType.AUDIO;
  487.       case 'video/webm':
  488.       case 'video/mp4':
  489.       case 'video/mpeg':
  490.       case 'video/mp2t':
  491.         return shaka.util.CmcdManager.ObjectType.MUXED;
  493.       case 'application/x-mpegurl':
  494.       case 'application/vnd.apple.mpegurl':
  495.       case 'application/dash+xml':
  496.       case 'video/vnd.mpeg.dash.mpd':
  497.       case 'application/vnd.ms-sstr+xml':
  498.         return shaka.util.CmcdManager.ObjectType.MANIFEST;
  500.       default:
  501.         return undefined;
  502.     }
  503.   }
  505.   /**
  506.    * Get the buffer length for a media type in milliseconds
  507.    *
  508.    * @param {string} type
  509.    * @return {number}
  510.    * @private
  511.    */
  512.   getBufferLength_(type) {
  513.     const ranges = this.playerInterface_.getBufferedInfo()[type];
  515.     if (!ranges.length) {
  516.       return NaN;
  517.     }
  519.     const start = this.playerInterface_.getCurrentTime();
  520.     const range = ranges.find((r) => r.start <= start && r.end >= start);
  522.     if (!range) {
  523.       return NaN;
  524.     }
  526.     return (range.end - start) * 1000;
  527.   }
  529.   /**
  530.    * Get the remaining buffer length for a media type in milliseconds
  531.    *
  532.    * @param {string} type
  533.    * @return {number}
  534.    * @private
  535.    */
  536.   getRemainingBufferLength_(type) {
  537.     const ranges = this.playerInterface_.getBufferedInfo()[type];
  539.     if (!ranges.length) {
  540.       return 0;
  541.     }
  543.     const start = this.playerInterface_.getCurrentTime();
  544.     const range = ranges.find((r) => r.start <= start && r.end >= start);
  546.     if (!range) {
  547.       return 0;
  548.     }
  550.     return (range.end - start) * 1000;
  551.   }
  553.   /**
  554.    * Constructs a relative path from a URL
  555.    *
  556.    * @param {string} url
  557.    * @param {string} base
  558.    * @return {string}
  559.    * @private
  560.    */
  561.   urlToRelativePath_(url, base) {
  562.     const to = new URL(url);
  563.     const from = new URL(base);
  565.     if (to.origin !== from.origin) {
  566.       return url;
  567.     }
  569.     const toPath = to.pathname.split('/').slice(1);
  570.     const fromPath = from.pathname.split('/').slice(1, -1);
  572.     // remove common parents
  573.     while (toPath[0] === fromPath[0]) {
  574.       toPath.shift();
  575.       fromPath.shift();
  576.     }
  578.     // add back paths
  579.     while (fromPath.length) {
  580.       fromPath.shift();
  581.       toPath.unshift('..');
  582.     }
  584.     return toPath.join('/');
  585.   }
  587.   /**
  588.    * Calculate requested maximun throughput
  589.    *
  590.    * @param {shaka.extern.Stream} stream
  591.    * @param {shaka.media.SegmentReference} segment
  592.    * @return {number}
  593.    * @private
  594.    */
  595.   calculateRtp_(stream, segment) {
  596.     const playbackRate = this.playerInterface_.getPlaybackRate() || 1;
  597.     const currentBufferLevel =
  598.         this.getRemainingBufferLength_(stream.type) || 500;
  599.     const bandwidth = stream.bandwidth;
  600.     if (!bandwidth) {
  601.       return NaN;
  602.     }
  603.     const segmentDuration = segment.endTime - segment.startTime;
  604.     // Calculate file size in kilobits
  605.     const segmentSize = bandwidth * segmentDuration / 1000;
  606.     // Calculate time available to load file in seconds
  607.     const timeToLoad = (currentBufferLevel / playbackRate) / 1000;
  608.     // Calculate the exact bandwidth required
  609.     const minBandwidth = segmentSize / timeToLoad;
  610.     // Include a safety buffer
  611.     return minBandwidth * this.config_.rtpSafetyFactor;
  612.   }
  614.   /**
  615.    * Get the stream format
  616.    *
  617.    * @param {shaka.net.NetworkingEngine.AdvancedRequestType} type
  618.    *   The request's advanced type
  619.    * @return {(shaka.util.CmcdManager.StreamingFormat|undefined)}
  620.    * @private
  621.    */
  622.   getStreamFormat_(type) {
  623.     const AdvancedRequestType = shaka.net.NetworkingEngine.AdvancedRequestType;
  625.     switch (type) {
  626.       case AdvancedRequestType.MPD:
  627.         return shaka.util.CmcdManager.StreamingFormat.DASH;
  629.       case AdvancedRequestType.MASTER_PLAYLIST:
  630.       case AdvancedRequestType.MEDIA_PLAYLIST:
  631.         return shaka.util.CmcdManager.StreamingFormat.HLS;
  633.       case AdvancedRequestType.MSS:
  634.         return shaka.util.CmcdManager.StreamingFormat.SMOOTH;
  635.     }
  637.     return undefined;
  638.   }
  640.   /**
  641.    * Get the stream type
  642.    *
  643.    * @return {shaka.util.CmcdManager.StreamType}
  644.    * @private
  645.    */
  646.   getStreamType_() {
  647.     const isLive = this.playerInterface_.isLive();
  648.     if (isLive) {
  649.       return shaka.util.CmcdManager.StreamType.LIVE;
  650.     } else {
  651.       return shaka.util.CmcdManager.StreamType.VOD;
  652.     }
  653.   }
  655.   /**
  656.    * Get the highest bandwidth for a given type.
  657.    *
  658.    * @param {string} type
  659.    * @return {number}
  660.    * @private
  661.    */
  662.   getTopBandwidth_(type) {
  663.     const variants = this.playerInterface_.getVariantTracks();
  664.     if (!variants.length) {
  665.       return NaN;
  666.     }
  668.     let top = variants[0];
  670.     for (const variant of variants) {
  671.       if (variant.type === 'variant' && variant.bandwidth > top.bandwidth) {
  672.         top = variant;
  673.       }
  674.     }
  676.     const ObjectType = shaka.util.CmcdManager.ObjectType;
  678.     switch (type) {
  679.       case ObjectType.VIDEO:
  680.         return top.videoBandwidth || NaN;
  682.       case ObjectType.AUDIO:
  683.         return top.audioBandwidth || NaN;
  685.       default:
  686.         return top.bandwidth;
  687.     }
  688.   }
  690.   /**
  691.    * Serialize a CMCD data object according to the rules defined in the
  692.    * section 3.2 of
  693.    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
  694.    *
  695.    * @param {CmcdData} data The CMCD data object
  696.    * @return {string}
  697.    */
  698.   static serialize(data) {
  699.     const results = [];
  700.     const isValid = (value) =>
  701.       !Number.isNaN(value) && value != null && value !== '' && value !== false;
  702.     const toRounded = (value) => Math.round(value);
  703.     const toHundred = (value) => toRounded(value / 100) * 100;
  704.     const toUrlSafe = (value) => encodeURIComponent(value);
  705.     const formatters = {
  706.       br: toRounded,
  707.       d: toRounded,
  708.       bl: toHundred,
  709.       dl: toHundred,
  710.       mtp: toHundred,
  711.       nor: toUrlSafe,
  712.       rtp: toHundred,
  713.       tb: toRounded,
  714.     };
  716.     const keys = Object.keys(data || {}).sort();
  718.     for (const key of keys) {
  719.       let value = data[key];
  721.       // ignore invalid values
  722.       if (!isValid(value)) {
  723.         continue;
  724.       }
  726.       // Version should only be reported if not equal to 1.
  727.       if (key === 'v' && value === 1) {
  728.         continue;
  729.       }
  731.       // Playback rate should only be sent if not equal to 1.
  732.       if (key == 'pr' && value === 1) {
  733.         continue;
  734.       }
  736.       // Certain values require special formatting
  737.       const formatter = formatters[key];
  738.       if (formatter) {
  739.         value = formatter(value);
  740.       }
  742.       // Serialize the key/value pair
  743.       const type = typeof value;
  744.       let result;
  746.       if (type === 'string' && key !== 'ot' && key !== 'sf' && key !== 'st') {
  747.         result = `${key}=${JSON.stringify(value)}`;
  748.       } else if (type === 'boolean') {
  749.         result = key;
  750.       } else if (type === 'symbol') {
  751.         result = `${key}=${value.description}`;
  752.       } else {
  753.         result = `${key}=${value}`;
  754.       }
  756.       results.push(result);
  757.     }
  759.     return results.join(',');
  760.   }
  762.   /**
  763.    * Convert a CMCD data object to request headers according to the rules
  764.    * defined in the section 2.1 and 3.2 of
  765.    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
  766.    *
  767.    * @param {CmcdData} data The CMCD data object
  768.    * @return {!Object}
  769.    */
  770.   static toHeaders(data) {
  771.     const keys = Object.keys(data);
  772.     const headers = {};
  773.     const headerNames = ['Object', 'Request', 'Session', 'Status'];
  774.     const headerGroups = [{}, {}, {}, {}];
  775.     const headerMap = {
  776.       br: 0, d: 0, ot: 0, tb: 0,
  777.       bl: 1, dl: 1, mtp: 1, nor: 1, nrr: 1, su: 1,
  778.       cid: 2, pr: 2, sf: 2, sid: 2, st: 2, v: 2,
  779.       bs: 3, rtp: 3,
  780.     };
  782.     for (const key of keys) {
  783.       // Unmapped fields are mapped to the Request header
  784.       const index = (headerMap[key] != null) ? headerMap[key] : 1;
  785.       headerGroups[index][key] = data[key];
  786.     }
  788.     for (let i = 0; i < headerGroups.length; i++) {
  789.       const value = shaka.util.CmcdManager.serialize(headerGroups[i]);
  790.       if (value) {
  791.         headers[`CMCD-${headerNames[i]}`] = value;
  792.       }
  793.     }
  795.     return headers;
  796.   }
  798.   /**
  799.    * Convert a CMCD data object to query args according to the rules
  800.    * defined in the section 2.2 and 3.2 of
  801.    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
  802.    *
  803.    * @param {CmcdData} data The CMCD data object
  804.    * @return {string}
  805.    */
  806.   static toQuery(data) {
  807.     return shaka.util.CmcdManager.serialize(data);
  808.   }
  810.   /**
  811.    * Append query args to a uri.
  812.    *
  813.    * @param {string} uri
  814.    * @param {string} query
  815.    * @return {string}
  816.    */
  817.   static appendQueryToUri(uri, query) {
  818.     if (!query) {
  819.       return uri;
  820.     }
  822.     if (uri.includes('offline:')) {
  823.       return uri;
  824.     }
  826.     const url = new goog.Uri(uri);
  827.     url.getQueryData().set('CMCD', query);
  828.     return url.toString();
  829.   }
  830. };
  833. /**
  834.  * @typedef {{
  835.  *   getBandwidthEstimate: function():number,
  836.  *   getBufferedInfo: function():shaka.extern.BufferedInfo,
  837.  *   getCurrentTime: function():number,
  838.  *   getPlaybackRate: function():number,
  839.  *   getVariantTracks: function():Array.<shaka.extern.Track>,
  840.  *   isLive: function():boolean
  841.  * }}
  842.  *
  843.  * @property {function():number} getBandwidthEstimate
  844.  *   Get the estimated bandwidth in bits per second.
  845.  * @property {function():shaka.extern.BufferedInfo} getBufferedInfo
  846.  *   Get information about what the player has buffered.
  847.  * @property {function():number} getCurrentTime
  848.  *   Get the current time
  849.  * @property {function():number} getPlaybackRate
  850.  *   Get the playback rate
  851.  * @property {function():Array.<shaka.extern.Track>} getVariantTracks
  852.  *   Get the variant tracks
  853.  * @property {function():boolean} isLive
  854.  *   Get if the player is playing live content.
  855.  */
  856. shaka.util.CmcdManager.PlayerInterface;
  859. /**
  860.  * @enum {string}
  861.  */
  862. shaka.util.CmcdManager.ObjectType = {
  863.   MANIFEST: 'm',
  864.   AUDIO: 'a',
  865.   VIDEO: 'v',
  866.   MUXED: 'av',
  867.   INIT: 'i',
  868.   CAPTION: 'c',
  869.   TIMED_TEXT: 'tt',
  870.   KEY: 'k',
  871.   OTHER: 'o',
  872. };
  875. /**
  876.  * @enum {string}
  877.  */
  878. shaka.util.CmcdManager.StreamType = {
  879.   VOD: 'v',
  880.   LIVE: 'l',
  881. };
  884. /**
  885.  * @enum {string}
  886.  * @export
  887.  */
  888. shaka.util.CmcdManager.StreamingFormat = {
  889.   DASH: 'd',
  890.   HLS: 'h',
  891.   SMOOTH: 's',
  892.   OTHER: 'o',
  893. };
  896. /**
  897.  * The CMCD spec version
  898.  * @const {number}
  899.  */
  900. shaka.util.CmcdManager.Version = 1;