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.   }
  66.   /**
  67.    * Set the buffering state
  68.    *
  69.    * @param {boolean} buffering
  70.    */
  71.   setBuffering(buffering) {
  72.     if (!buffering && !this.playbackStarted_) {
  73.       this.playbackStarted_ = true;
  74.     }
  76.     if (this.playbackStarted_ && buffering) {
  77.       this.starved_ = true;
  78.     }
  80.     this.buffering_ = buffering;
  81.   }
  83.   /**
  84.    * Apply CMCD data to a request.
  85.    *
  86.    * @param {!shaka.net.NetworkingEngine.RequestType} type
  87.    *   The request type
  88.    * @param {!shaka.extern.Request} request
  89.    *   The request to apply CMCD data to
  90.    * @param {shaka.extern.RequestContext=} context
  91.    *   The request context
  92.    */
  93.   applyData(type, request, context = {}) {
  94.     if (!this.config_.enabled) {
  95.       return;
  96.     }
  98.     if (request.method === 'HEAD') {
  99.       this.apply_(request);
  100.       return;
  101.     }
  103.     const RequestType = shaka.net.NetworkingEngine.RequestType;
  104.     const ObjectType = shaka.util.CmcdManager.ObjectType;
  106.     switch (type) {
  107.       case RequestType.MANIFEST:
  108.         this.applyManifestData(request, context);
  109.         break;
  111.       case RequestType.SEGMENT:
  112.         this.applySegmentData(request, context);
  113.         break;
  115.       case RequestType.LICENSE:
  116.       case RequestType.SERVER_CERTIFICATE:
  117.       case RequestType.KEY:
  118.         this.apply_(request, {ot: ObjectType.KEY});
  119.         break;
  121.       case RequestType.TIMING:
  122.         this.apply_(request, {ot: ObjectType.OTHER});
  123.         break;
  124.     }
  125.   }
  127.   /**
  128.    * Apply CMCD data to a manifest request.
  129.    *
  130.    * @param {!shaka.extern.Request} request
  131.    *   The request to apply CMCD data to
  132.    * @param {shaka.extern.RequestContext} context
  133.    *   The request context
  134.    */
  135.   applyManifestData(request, context) {
  136.     try {
  137.       if (!this.config_.enabled) {
  138.         return;
  139.       }
  141.       if (context.type) {
  142.         this.sf_ = this.getStreamFormat_(context.type);
  143.       }
  145.       this.apply_(request, {
  146.         ot: shaka.util.CmcdManager.ObjectType.MANIFEST,
  147.         su: !this.playbackStarted_,
  148.       });
  149.     } catch (error) {
  150.       shaka.log.warnOnce('CMCD_MANIFEST_ERROR',
  151.           'Could not generate manifest CMCD data.', error);
  152.     }
  153.   }
  155.   /**
  156.    * Apply CMCD data to a segment request
  157.    *
  158.    * @param {!shaka.extern.Request} request
  159.    * @param {shaka.extern.RequestContext} context
  160.    *   The request context
  161.    */
  162.   applySegmentData(request, context) {
  163.     try {
  164.       if (!this.config_.enabled) {
  165.         return;
  166.       }
  168.       const segment = context.segment;
  170.       let duration = 0;
  171.       if (segment) {
  172.         duration = segment.endTime - segment.startTime;
  173.       }
  175.       const data = {
  176.         d: duration * 1000,
  177.         st: this.getStreamType_(),
  178.       };
  180.       data.ot = this.getObjectType_(context);
  182.       const ObjectType = shaka.util.CmcdManager.ObjectType;
  183.       const isMedia = data.ot === ObjectType.VIDEO ||
  184.           data.ot === ObjectType.AUDIO ||
  185.           data.ot === ObjectType.MUXED ||
  186.           data.ot === ObjectType.TIMED_TEXT;
  188.       const stream = context.stream;
  189.       if (stream) {
  190.         const playbackRate = this.playerInterface_.getPlaybackRate();
  191.         if (isMedia) {
  192.           data.bl = this.getBufferLength_(stream.type);
  193.           if (data.ot !== ObjectType.TIMED_TEXT) {
  194.             const remainingBufferLength =
  195.                 this.getRemainingBufferLength_(stream.type);
  196.             if (playbackRate) {
  197.               data.dl = remainingBufferLength / Math.abs(playbackRate);
  198.             } else {
  199.               data.dl = remainingBufferLength;
  200.             }
  201.           }
  202.         }
  204.         if (stream.bandwidth) {
  205.           data.br = stream.bandwidth / 1000;
  206.         }
  208.         if (stream.segmentIndex && segment) {
  209.           const reverse = playbackRate < 0;
  210.           const iterator = stream.segmentIndex.getIteratorForTime(
  211.               segment.endTime, /* allowNonIndepedent= */ true, reverse);
  212.           if (iterator) {
  213.             const nextSegment = iterator.next().value;
  214.             if (nextSegment && nextSegment != segment) {
  215.               if (!shaka.util.ArrayUtils.equal(
  216.                   segment.getUris(), nextSegment.getUris())) {
  217.                 data.nor = this.urlToRelativePath_(
  218.                     nextSegment.getUris()[0], request.uris[0]);
  219.               }
  220.               if ((nextSegment.startByte || nextSegment.endByte) &&
  221.                   (segment.startByte != nextSegment.startByte ||
  222.                   segment.endByte != nextSegment.endByte)) {
  223.                 let range = nextSegment.startByte + '-';
  224.                 if (nextSegment.endByte) {
  225.                   range += nextSegment.endByte;
  226.                 }
  227.                 data.nrr = range;
  228.               }
  229.             }
  230.           }
  231.           const rtp = this.calculateRtp_(stream, segment);
  232.           if (!isNaN(rtp)) {
  233.             data.rtp = rtp;
  234.           }
  235.         }
  236.       }
  238.       if (isMedia && data.ot !== ObjectType.TIMED_TEXT) {
  239.         data.tb = this.getTopBandwidth_(data.ot) / 1000;
  240.       }
  242.       this.apply_(request, data);
  243.     } catch (error) {
  244.       shaka.log.warnOnce('CMCD_SEGMENT_ERROR',
  245.           'Could not generate segment CMCD data.', error);
  246.     }
  247.   }
  249.   /**
  250.    * Apply CMCD data to a text request
  251.    *
  252.    * @param {!shaka.extern.Request} request
  253.    */
  254.   applyTextData(request) {
  255.     try {
  256.       if (!this.config_.enabled) {
  257.         return;
  258.       }
  260.       this.apply_(request, {
  261.         ot: shaka.util.CmcdManager.ObjectType.CAPTION,
  262.         su: true,
  263.       });
  264.     } catch (error) {
  265.       shaka.log.warnOnce('CMCD_TEXT_ERROR',
  266.           'Could not generate text CMCD data.', error);
  267.     }
  268.   }
  270.   /**
  271.    * Apply CMCD data to streams loaded via src=.
  272.    *
  273.    * @param {string} uri
  274.    * @param {string} mimeType
  275.    * @return {string}
  276.    */
  277.   appendSrcData(uri, mimeType) {
  278.     try {
  279.       if (!this.config_.enabled) {
  280.         return uri;
  281.       }
  283.       const data = this.createData_();
  284.       data.ot = this.getObjectTypeFromMimeType_(mimeType);
  285.       data.su = true;
  287.       const query = shaka.util.CmcdManager.toQuery(data);
  289.       return shaka.util.CmcdManager.appendQueryToUri(uri, query);
  290.     } catch (error) {
  291.       shaka.log.warnOnce('CMCD_SRC_ERROR',
  292.           'Could not generate src CMCD data.', error);
  293.       return uri;
  294.     }
  295.   }
  297.   /**
  298.    * Apply CMCD data to side car text track uri.
  299.    *
  300.    * @param {string} uri
  301.    * @return {string}
  302.    */
  303.   appendTextTrackData(uri) {
  304.     try {
  305.       if (!this.config_.enabled) {
  306.         return uri;
  307.       }
  309.       const data = this.createData_();
  310.       data.ot = shaka.util.CmcdManager.ObjectType.CAPTION;
  311.       data.su = true;
  313.       const query = shaka.util.CmcdManager.toQuery(data);
  315.       return shaka.util.CmcdManager.appendQueryToUri(uri, query);
  316.     } catch (error) {
  317.       shaka.log.warnOnce('CMCD_TEXT_TRACK_ERROR',
  318.           'Could not generate text track CMCD data.', error);
  319.       return uri;
  320.     }
  321.   }
  323.   /**
  324.    * Create baseline CMCD data
  325.    *
  326.    * @return {CmcdData}
  327.    * @private
  328.    */
  329.   createData_() {
  330.     if (!this.config_.sessionId) {
  331.       this.config_.sessionId = window.crypto.randomUUID();
  332.     }
  333.     return {
  334.       v: shaka.util.CmcdManager.Version,
  335.       sf: this.sf_,
  336.       sid: this.config_.sessionId,
  337.       cid: this.config_.contentId,
  338.       mtp: this.playerInterface_.getBandwidthEstimate() / 1000,
  339.     };
  340.   }
  342.   /**
  343.    * Apply CMCD data to a request.
  344.    *
  345.    * @param {!shaka.extern.Request} request The request to apply CMCD data to
  346.    * @param {!CmcdData} data The data object
  347.    * @param {boolean} useHeaders Send data via request headers
  348.    * @private
  349.    */
  350.   apply_(request, data = {}, useHeaders = this.config_.useHeaders) {
  351.     if (!this.config_.enabled) {
  352.       return;
  353.     }
  355.     // apply baseline data
  356.     Object.assign(data, this.createData_());
  358.     data.pr = this.playerInterface_.getPlaybackRate();
  360.     const isVideo = data.ot === shaka.util.CmcdManager.ObjectType.VIDEO ||
  361.         data.ot === shaka.util.CmcdManager.ObjectType.MUXED;
  363.     if (this.starved_ && isVideo) {
  364.       data.bs = true;
  365.       data.su = true;
  366.       this.starved_ = false;
  367.     }
  369.     if (data.su == null) {
  370.       data.su = this.buffering_;
  371.     }
  373.     const output = this.filterKeys_(data);
  375.     if (useHeaders) {
  376.       const headers = shaka.util.CmcdManager.toHeaders(output);
  377.       if (!Object.keys(headers).length) {
  378.         return;
  379.       }
  381.       Object.assign(request.headers, headers);
  382.     } else {
  383.       const query = shaka.util.CmcdManager.toQuery(output);
  384.       if (!query) {
  385.         return;
  386.       }
  388.       request.uris = request.uris.map((uri) => {
  389.         return shaka.util.CmcdManager.appendQueryToUri(uri, query);
  390.       });
  391.     }
  392.   }
  394.   /**
  395.    * Filter the CMCD data object to include only the keys specified in the
  396.    * configuration.
  397.    *
  398.    * @param {CmcdData} data
  399.    * @return {CmcdData}
  400.    * @private
  401.    */
  402.   filterKeys_(data) {
  403.     const includeKeys = this.config_.includeKeys;
  405.     if (!includeKeys.length) {
  406.       return data;
  407.     }
  409.     return Object.keys(data).reduce((acc, key) => {
  410.       if (includeKeys.includes(key)) {
  411.         acc[key] = data[key];
  412.       }
  413.       return acc;
  414.     }, {});
  415.   }
  417.   /**
  418.    * The CMCD object type.
  419.    *
  420.    * @param {shaka.extern.RequestContext} context
  421.    *   The request context
  422.    * @private
  423.    */
  424.   getObjectType_(context) {
  425.     if (context.type ===
  426.         shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT) {
  427.       return shaka.util.CmcdManager.ObjectType.INIT;
  428.     }
  430.     const stream = context.stream;
  432.     if (!stream) {
  433.       return undefined;
  434.     }
  436.     const type = stream.type;
  438.     if (type == 'video') {
  439.       if (stream.codecs && stream.codecs.includes(',')) {
  440.         return shaka.util.CmcdManager.ObjectType.MUXED;
  441.       }
  442.       return shaka.util.CmcdManager.ObjectType.VIDEO;
  443.     }
  445.     if (type == 'audio') {
  446.       return shaka.util.CmcdManager.ObjectType.AUDIO;
  447.     }
  449.     if (type == 'text') {
  450.       if (stream.mimeType === 'application/mp4') {
  451.         return shaka.util.CmcdManager.ObjectType.TIMED_TEXT;
  452.       }
  453.       return shaka.util.CmcdManager.ObjectType.CAPTION;
  454.     }
  456.     return undefined;
  457.   }
  459.   /**
  460.    * The CMCD object type from mimeType.
  461.    *
  462.    * @param {!string} mimeType
  463.    * @return {(shaka.util.CmcdManager.ObjectType|undefined)}
  464.    * @private
  465.    */
  466.   getObjectTypeFromMimeType_(mimeType) {
  467.     switch (mimeType.toLowerCase()) {
  468.       case 'audio/mp4':
  469.       case 'audio/webm':
  470.       case 'audio/ogg':
  471.       case 'audio/mpeg':
  472.       case 'audio/aac':
  473.       case 'audio/flac':
  474.       case 'audio/wav':
  475.         return shaka.util.CmcdManager.ObjectType.AUDIO;
  477.       case 'video/webm':
  478.       case 'video/mp4':
  479.       case 'video/mpeg':
  480.       case 'video/mp2t':
  481.         return shaka.util.CmcdManager.ObjectType.MUXED;
  483.       case 'application/x-mpegurl':
  484.       case 'application/vnd.apple.mpegurl':
  485.       case 'application/dash+xml':
  486.       case 'video/vnd.mpeg.dash.mpd':
  487.       case 'application/vnd.ms-sstr+xml':
  488.         return shaka.util.CmcdManager.ObjectType.MANIFEST;
  490.       default:
  491.         return undefined;
  492.     }
  493.   }
  495.   /**
  496.    * Get the buffer length for a media type in milliseconds
  497.    *
  498.    * @param {string} type
  499.    * @return {number}
  500.    * @private
  501.    */
  502.   getBufferLength_(type) {
  503.     const ranges = this.playerInterface_.getBufferedInfo()[type];
  505.     if (!ranges.length) {
  506.       return NaN;
  507.     }
  509.     const start = this.playerInterface_.getCurrentTime();
  510.     const range = ranges.find((r) => r.start <= start && r.end >= start);
  512.     if (!range) {
  513.       return NaN;
  514.     }
  516.     return (range.end - start) * 1000;
  517.   }
  519.   /**
  520.    * Get the remaining buffer length for a media type in milliseconds
  521.    *
  522.    * @param {string} type
  523.    * @return {number}
  524.    * @private
  525.    */
  526.   getRemainingBufferLength_(type) {
  527.     const ranges = this.playerInterface_.getBufferedInfo()[type];
  529.     if (!ranges.length) {
  530.       return 0;
  531.     }
  533.     const start = this.playerInterface_.getCurrentTime();
  534.     const range = ranges.find((r) => r.start <= start && r.end >= start);
  536.     if (!range) {
  537.       return 0;
  538.     }
  540.     return (range.end - start) * 1000;
  541.   }
  543.   /**
  544.    * Constructs a relative path from a URL
  545.    *
  546.    * @param {string} url
  547.    * @param {string} base
  548.    * @return {string}
  549.    * @private
  550.    */
  551.   urlToRelativePath_(url, base) {
  552.     const to = new URL(url);
  553.     const from = new URL(base);
  555.     if (to.origin !== from.origin) {
  556.       return url;
  557.     }
  559.     const toPath = to.pathname.split('/').slice(1);
  560.     const fromPath = from.pathname.split('/').slice(1, -1);
  562.     // remove common parents
  563.     while (toPath[0] === fromPath[0]) {
  564.       toPath.shift();
  565.       fromPath.shift();
  566.     }
  568.     // add back paths
  569.     while (fromPath.length) {
  570.       fromPath.shift();
  571.       toPath.unshift('..');
  572.     }
  574.     return toPath.join('/');
  575.   }
  577.   /**
  578.    * Calculate requested maximun throughput
  579.    *
  580.    * @param {shaka.extern.Stream} stream
  581.    * @param {shaka.media.SegmentReference} segment
  582.    * @return {number}
  583.    * @private
  584.    */
  585.   calculateRtp_(stream, segment) {
  586.     const playbackRate = this.playerInterface_.getPlaybackRate() || 1;
  587.     const currentBufferLevel =
  588.         this.getRemainingBufferLength_(stream.type) || 500;
  589.     const bandwidth = stream.bandwidth;
  590.     if (!bandwidth) {
  591.       return NaN;
  592.     }
  593.     const segmentDuration = segment.endTime - segment.startTime;
  594.     // Calculate file size in kilobits
  595.     const segmentSize = bandwidth * segmentDuration / 1000;
  596.     // Calculate time available to load file in seconds
  597.     const timeToLoad = (currentBufferLevel / playbackRate) / 1000;
  598.     // Calculate the exact bandwidth required
  599.     const minBandwidth = segmentSize / timeToLoad;
  600.     // Include a safety buffer
  601.     return minBandwidth * this.config_.rtpSafetyFactor;
  602.   }
  604.   /**
  605.    * Get the stream format
  606.    *
  607.    * @param {shaka.net.NetworkingEngine.AdvancedRequestType} type
  608.    *   The request's advanced type
  609.    * @return {(shaka.util.CmcdManager.StreamingFormat|undefined)}
  610.    * @private
  611.    */
  612.   getStreamFormat_(type) {
  613.     const AdvancedRequestType = shaka.net.NetworkingEngine.AdvancedRequestType;
  615.     switch (type) {
  616.       case AdvancedRequestType.MPD:
  617.         return shaka.util.CmcdManager.StreamingFormat.DASH;
  619.       case AdvancedRequestType.MASTER_PLAYLIST:
  620.       case AdvancedRequestType.MEDIA_PLAYLIST:
  621.         return shaka.util.CmcdManager.StreamingFormat.HLS;
  623.       case AdvancedRequestType.MSS:
  624.         return shaka.util.CmcdManager.StreamingFormat.SMOOTH;
  625.     }
  627.     return undefined;
  628.   }
  630.   /**
  631.    * Get the stream type
  632.    *
  633.    * @return {shaka.util.CmcdManager.StreamType}
  634.    * @private
  635.    */
  636.   getStreamType_() {
  637.     const isLive = this.playerInterface_.isLive();
  638.     if (isLive) {
  639.       return shaka.util.CmcdManager.StreamType.LIVE;
  640.     } else {
  641.       return shaka.util.CmcdManager.StreamType.VOD;
  642.     }
  643.   }
  645.   /**
  646.    * Get the highest bandwidth for a given type.
  647.    *
  648.    * @param {string} type
  649.    * @return {number}
  650.    * @private
  651.    */
  652.   getTopBandwidth_(type) {
  653.     const variants = this.playerInterface_.getVariantTracks();
  654.     if (!variants.length) {
  655.       return NaN;
  656.     }
  658.     let top = variants[0];
  660.     for (const variant of variants) {
  661.       if (variant.type === 'variant' && variant.bandwidth > top.bandwidth) {
  662.         top = variant;
  663.       }
  664.     }
  666.     const ObjectType = shaka.util.CmcdManager.ObjectType;
  668.     switch (type) {
  669.       case ObjectType.VIDEO:
  670.         return top.videoBandwidth || NaN;
  672.       case ObjectType.AUDIO:
  673.         return top.audioBandwidth || NaN;
  675.       default:
  676.         return top.bandwidth;
  677.     }
  678.   }
  680.   /**
  681.    * Serialize a CMCD data object according to the rules defined in the
  682.    * section 3.2 of
  683.    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
  684.    *
  685.    * @param {CmcdData} data The CMCD data object
  686.    * @return {string}
  687.    */
  688.   static serialize(data) {
  689.     const results = [];
  690.     const isValid = (value) =>
  691.       !Number.isNaN(value) && value != null && value !== '' && value !== false;
  692.     const toRounded = (value) => Math.round(value);
  693.     const toHundred = (value) => toRounded(value / 100) * 100;
  694.     const toUrlSafe = (value) => encodeURIComponent(value);
  695.     const formatters = {
  696.       br: toRounded,
  697.       d: toRounded,
  698.       bl: toHundred,
  699.       dl: toHundred,
  700.       mtp: toHundred,
  701.       nor: toUrlSafe,
  702.       rtp: toHundred,
  703.       tb: toRounded,
  704.     };
  706.     const keys = Object.keys(data || {}).sort();
  708.     for (const key of keys) {
  709.       let value = data[key];
  711.       // ignore invalid values
  712.       if (!isValid(value)) {
  713.         continue;
  714.       }
  716.       // Version should only be reported if not equal to 1.
  717.       if (key === 'v' && value === 1) {
  718.         continue;
  719.       }
  721.       // Playback rate should only be sent if not equal to 1.
  722.       if (key == 'pr' && value === 1) {
  723.         continue;
  724.       }
  726.       // Certain values require special formatting
  727.       const formatter = formatters[key];
  728.       if (formatter) {
  729.         value = formatter(value);
  730.       }
  732.       // Serialize the key/value pair
  733.       const type = typeof value;
  734.       let result;
  736.       if (type === 'string' && key !== 'ot' && key !== 'sf' && key !== 'st') {
  737.         result = `${key}=${JSON.stringify(value)}`;
  738.       } else if (type === 'boolean') {
  739.         result = key;
  740.       } else if (type === 'symbol') {
  741.         result = `${key}=${value.description}`;
  742.       } else {
  743.         result = `${key}=${value}`;
  744.       }
  746.       results.push(result);
  747.     }
  749.     return results.join(',');
  750.   }
  752.   /**
  753.    * Convert a CMCD data object to request headers according to the rules
  754.    * defined in the section 2.1 and 3.2 of
  755.    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
  756.    *
  757.    * @param {CmcdData} data The CMCD data object
  758.    * @return {!Object}
  759.    */
  760.   static toHeaders(data) {
  761.     const keys = Object.keys(data);
  762.     const headers = {};
  763.     const headerNames = ['Object', 'Request', 'Session', 'Status'];
  764.     const headerGroups = [{}, {}, {}, {}];
  765.     const headerMap = {
  766.       br: 0, d: 0, ot: 0, tb: 0,
  767.       bl: 1, dl: 1, mtp: 1, nor: 1, nrr: 1, su: 1,
  768.       cid: 2, pr: 2, sf: 2, sid: 2, st: 2, v: 2,
  769.       bs: 3, rtp: 3,
  770.     };
  772.     for (const key of keys) {
  773.       // Unmapped fields are mapped to the Request header
  774.       const index = (headerMap[key] != null) ? headerMap[key] : 1;
  775.       headerGroups[index][key] = data[key];
  776.     }
  778.     for (let i = 0; i < headerGroups.length; i++) {
  779.       const value = shaka.util.CmcdManager.serialize(headerGroups[i]);
  780.       if (value) {
  781.         headers[`CMCD-${headerNames[i]}`] = value;
  782.       }
  783.     }
  785.     return headers;
  786.   }
  788.   /**
  789.    * Convert a CMCD data object to query args according to the rules
  790.    * defined in the section 2.2 and 3.2 of
  791.    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
  792.    *
  793.    * @param {CmcdData} data The CMCD data object
  794.    * @return {string}
  795.    */
  796.   static toQuery(data) {
  797.     return shaka.util.CmcdManager.serialize(data);
  798.   }
  800.   /**
  801.    * Append query args to a uri.
  802.    *
  803.    * @param {string} uri
  804.    * @param {string} query
  805.    * @return {string}
  806.    */
  807.   static appendQueryToUri(uri, query) {
  808.     if (!query) {
  809.       return uri;
  810.     }
  812.     if (uri.includes('offline:')) {
  813.       return uri;
  814.     }
  816.     const url = new goog.Uri(uri);
  817.     url.getQueryData().set('CMCD', query);
  818.     return url.toString();
  819.   }
  820. };
  823. /**
  824.  * @typedef {{
  825.  *   getBandwidthEstimate: function():number,
  826.  *   getBufferedInfo: function():shaka.extern.BufferedInfo,
  827.  *   getCurrentTime: function():number,
  828.  *   getPlaybackRate: function():number,
  829.  *   getVariantTracks: function():Array.<shaka.extern.Track>,
  830.  *   isLive: function():boolean
  831.  * }}
  832.  *
  833.  * @property {function():number} getBandwidthEstimate
  834.  *   Get the estimated bandwidth in bits per second.
  835.  * @property {function():shaka.extern.BufferedInfo} getBufferedInfo
  836.  *   Get information about what the player has buffered.
  837.  * @property {function():number} getCurrentTime
  838.  *   Get the current time
  839.  * @property {function():number} getPlaybackRate
  840.  *   Get the playback rate
  841.  * @property {function():Array.<shaka.extern.Track>} getVariantTracks
  842.  *   Get the variant tracks
  843.  * @property {function():boolean} isLive
  844.  *   Get if the player is playing live content.
  845.  */
  846. shaka.util.CmcdManager.PlayerInterface;
  849. /**
  850.  * @enum {string}
  851.  */
  852. shaka.util.CmcdManager.ObjectType = {
  853.   MANIFEST: 'm',
  854.   AUDIO: 'a',
  855.   VIDEO: 'v',
  856.   MUXED: 'av',
  857.   INIT: 'i',
  858.   CAPTION: 'c',
  859.   TIMED_TEXT: 'tt',
  860.   KEY: 'k',
  861.   OTHER: 'o',
  862. };
  865. /**
  866.  * @enum {string}
  867.  */
  868. shaka.util.CmcdManager.StreamType = {
  869.   VOD: 'v',
  870.   LIVE: 'l',
  871. };
  874. /**
  875.  * @enum {string}
  876.  * @export
  877.  */
  878. shaka.util.CmcdManager.StreamingFormat = {
  879.   DASH: 'd',
  880.   HLS: 'h',
  881.   SMOOTH: 's',
  882.   OTHER: 'o',
  883. };
  886. /**
  887.  * The CMCD spec version
  888.  * @const {number}
  889.  */
  890. shaka.util.CmcdManager.Version = 1;