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;
  55.     /**
  56.      * @private {boolean}
  57.      */
  58.     this.lowLatency_ = false;
  59.   }
  61.   /**
  62.    * Called by the Player to provide an updated configuration any time it
  63.    * changes.
  64.    *
  65.    * @param {shaka.extern.CmcdConfiguration} config
  66.    */
  67.   configure(config) {
  68.     this.config_ = config;
  69.   }
  72.   /**
  73.    * Resets the CmcdManager.
  74.    */
  75.   reset() {
  76.     this.playbackStarted_ = false;
  77.     this.buffering_ = true;
  78.     this.starved_ = false;
  79.     this.lowLatency_ = false;
  80.   }
  82.   /**
  83.    * Set the buffering state
  84.    *
  85.    * @param {boolean} buffering
  86.    */
  87.   setBuffering(buffering) {
  88.     if (!buffering && !this.playbackStarted_) {
  89.       this.playbackStarted_ = true;
  90.     }
  92.     if (this.playbackStarted_ && buffering) {
  93.       this.starved_ = true;
  94.     }
  96.     this.buffering_ = buffering;
  97.   }
  99.   /**
  100.    * Set the low latency
  101.    *
  102.    * @param {boolean} lowLatency
  103.    */
  104.   setLowLatency(lowLatency) {
  105.     this.lowLatency_ = lowLatency;
  107.     const StreamingFormat = shaka.util.CmcdManager.StreamingFormat;
  108.     if (this.lowLatency_) {
  109.       if (this.sf_ == StreamingFormat.DASH) {
  110.         this.sf_ = StreamingFormat.LOW_LATENCY_DASH;
  111.       } else if (this.sf_ == StreamingFormat.HLS) {
  112.         this.sf_ = StreamingFormat.LOW_LATENCY_HLS;
  113.       }
  114.     } else {
  115.       if (this.sf_ == StreamingFormat.LOW_LATENCY_DASH) {
  116.         this.sf_ = StreamingFormat.DASH;
  117.       } else if (this.sf_ == StreamingFormat.LOW_LATENCY_HLS) {
  118.         this.sf_ = StreamingFormat.HLS;
  119.       }
  120.     }
  121.   }
  123.   /**
  124.    * Apply CMCD data to a request.
  125.    *
  126.    * @param {!shaka.net.NetworkingEngine.RequestType} type
  127.    *   The request type
  128.    * @param {!shaka.extern.Request} request
  129.    *   The request to apply CMCD data to
  130.    * @param {shaka.extern.RequestContext=} context
  131.    *   The request context
  132.    */
  133.   applyData(type, request, context = {}) {
  134.     if (!this.config_.enabled) {
  135.       return;
  136.     }
  138.     if (request.method === 'HEAD') {
  139.       this.apply_(request);
  140.       return;
  141.     }
  143.     const RequestType = shaka.net.NetworkingEngine.RequestType;
  144.     const ObjectType = shaka.util.CmcdManager.ObjectType;
  146.     switch (type) {
  147.       case RequestType.MANIFEST:
  148.         this.applyManifestData(request, context);
  149.         break;
  151.       case RequestType.SEGMENT:
  152.         this.applySegmentData(request, context);
  153.         break;
  155.       case RequestType.LICENSE:
  156.       case RequestType.SERVER_CERTIFICATE:
  157.       case RequestType.KEY:
  158.         this.apply_(request, {ot: ObjectType.KEY});
  159.         break;
  161.       case RequestType.TIMING:
  162.         this.apply_(request, {ot: ObjectType.OTHER});
  163.         break;
  164.     }
  165.   }
  167.   /**
  168.    * Apply CMCD data to a manifest request.
  169.    *
  170.    * @param {!shaka.extern.Request} request
  171.    *   The request to apply CMCD data to
  172.    * @param {shaka.extern.RequestContext} context
  173.    *   The request context
  174.    */
  175.   applyManifestData(request, context) {
  176.     try {
  177.       if (!this.config_.enabled) {
  178.         return;
  179.       }
  181.       if (context.type) {
  182.         this.sf_ = this.getStreamFormat_(context.type);
  183.       }
  185.       this.apply_(request, {
  186.         ot: shaka.util.CmcdManager.ObjectType.MANIFEST,
  187.         su: !this.playbackStarted_,
  188.       });
  189.     } catch (error) {
  190.       shaka.log.warnOnce('CMCD_MANIFEST_ERROR',
  191.           'Could not generate manifest CMCD data.', error);
  192.     }
  193.   }
  195.   /**
  196.    * Apply CMCD data to a segment request
  197.    *
  198.    * @param {!shaka.extern.Request} request
  199.    * @param {shaka.extern.RequestContext} context
  200.    *   The request context
  201.    */
  202.   applySegmentData(request, context) {
  203.     try {
  204.       if (!this.config_.enabled) {
  205.         return;
  206.       }
  208.       const segment = context.segment;
  210.       let duration = 0;
  211.       if (segment) {
  212.         duration = segment.endTime - segment.startTime;
  213.       }
  215.       const data = {
  216.         d: duration * 1000,
  217.         st: this.getStreamType_(),
  218.       };
  220.       data.ot = this.getObjectType_(context);
  222.       const ObjectType = shaka.util.CmcdManager.ObjectType;
  223.       const isMedia = data.ot === ObjectType.VIDEO ||
  224.           data.ot === ObjectType.AUDIO ||
  225.           data.ot === ObjectType.MUXED ||
  226.           data.ot === ObjectType.TIMED_TEXT;
  228.       const stream = context.stream;
  229.       if (stream) {
  230.         const playbackRate = this.playerInterface_.getPlaybackRate();
  231.         if (isMedia) {
  232.           data.bl = this.getBufferLength_(stream.type);
  233.           if (data.ot !== ObjectType.TIMED_TEXT) {
  234.             const remainingBufferLength =
  235.                 this.getRemainingBufferLength_(stream.type);
  236.             if (playbackRate) {
  237.               data.dl = remainingBufferLength / Math.abs(playbackRate);
  238.             } else {
  239.               data.dl = remainingBufferLength;
  240.             }
  241.           }
  242.         }
  244.         if (stream.bandwidth) {
  245.           data.br = stream.bandwidth / 1000;
  246.         }
  248.         if (stream.segmentIndex && segment) {
  249.           const reverse = playbackRate < 0;
  250.           const iterator = stream.segmentIndex.getIteratorForTime(
  251.               segment.endTime, /* allowNonIndepedent= */ true, reverse);
  252.           if (iterator) {
  253.             const nextSegment = iterator.next().value;
  254.             if (nextSegment && nextSegment != segment) {
  255.               if (!shaka.util.ArrayUtils.equal(
  256.                   segment.getUris(), nextSegment.getUris())) {
  257.                 data.nor = this.urlToRelativePath_(
  258.                     nextSegment.getUris()[0], request.uris[0]);
  259.               }
  260.               if ((nextSegment.startByte || nextSegment.endByte) &&
  261.                   (segment.startByte != nextSegment.startByte ||
  262.                   segment.endByte != nextSegment.endByte)) {
  263.                 let range = nextSegment.startByte + '-';
  264.                 if (nextSegment.endByte) {
  265.                   range += nextSegment.endByte;
  266.                 }
  267.                 data.nrr = range;
  268.               }
  269.             }
  270.           }
  271.           const rtp = this.calculateRtp_(stream, segment);
  272.           if (!isNaN(rtp)) {
  273.             data.rtp = rtp;
  274.           }
  275.         }
  276.       }
  278.       if (isMedia && data.ot !== ObjectType.TIMED_TEXT) {
  279.         data.tb = this.getTopBandwidth_(data.ot) / 1000;
  280.       }
  282.       this.apply_(request, data);
  283.     } catch (error) {
  284.       shaka.log.warnOnce('CMCD_SEGMENT_ERROR',
  285.           'Could not generate segment CMCD data.', error);
  286.     }
  287.   }
  289.   /**
  290.    * Apply CMCD data to a text request
  291.    *
  292.    * @param {!shaka.extern.Request} request
  293.    */
  294.   applyTextData(request) {
  295.     try {
  296.       if (!this.config_.enabled) {
  297.         return;
  298.       }
  300.       this.apply_(request, {
  301.         ot: shaka.util.CmcdManager.ObjectType.CAPTION,
  302.         su: true,
  303.       });
  304.     } catch (error) {
  305.       shaka.log.warnOnce('CMCD_TEXT_ERROR',
  306.           'Could not generate text CMCD data.', error);
  307.     }
  308.   }
  310.   /**
  311.    * Apply CMCD data to streams loaded via src=.
  312.    *
  313.    * @param {string} uri
  314.    * @param {string} mimeType
  315.    * @return {string}
  316.    */
  317.   appendSrcData(uri, mimeType) {
  318.     try {
  319.       if (!this.config_.enabled) {
  320.         return uri;
  321.       }
  323.       const data = this.createData_();
  324.       data.ot = this.getObjectTypeFromMimeType_(mimeType);
  325.       data.su = true;
  327.       const query = shaka.util.CmcdManager.toQuery(data);
  329.       return shaka.util.CmcdManager.appendQueryToUri(uri, query);
  330.     } catch (error) {
  331.       shaka.log.warnOnce('CMCD_SRC_ERROR',
  332.           'Could not generate src CMCD data.', error);
  333.       return uri;
  334.     }
  335.   }
  337.   /**
  338.    * Apply CMCD data to side car text track uri.
  339.    *
  340.    * @param {string} uri
  341.    * @return {string}
  342.    */
  343.   appendTextTrackData(uri) {
  344.     try {
  345.       if (!this.config_.enabled) {
  346.         return uri;
  347.       }
  349.       const data = this.createData_();
  350.       data.ot = shaka.util.CmcdManager.ObjectType.CAPTION;
  351.       data.su = true;
  353.       const query = shaka.util.CmcdManager.toQuery(data);
  355.       return shaka.util.CmcdManager.appendQueryToUri(uri, query);
  356.     } catch (error) {
  357.       shaka.log.warnOnce('CMCD_TEXT_TRACK_ERROR',
  358.           'Could not generate text track CMCD data.', error);
  359.       return uri;
  360.     }
  361.   }
  363.   /**
  364.    * Create baseline CMCD data
  365.    *
  366.    * @return {CmcdData}
  367.    * @private
  368.    */
  369.   createData_() {
  370.     if (!this.config_.sessionId) {
  371.       this.config_.sessionId = window.crypto.randomUUID();
  372.     }
  373.     return {
  374.       v: shaka.util.CmcdManager.Version,
  375.       sf: this.sf_,
  376.       sid: this.config_.sessionId,
  377.       cid: this.config_.contentId,
  378.       mtp: this.playerInterface_.getBandwidthEstimate() / 1000,
  379.     };
  380.   }
  382.   /**
  383.    * Apply CMCD data to a request.
  384.    *
  385.    * @param {!shaka.extern.Request} request The request to apply CMCD data to
  386.    * @param {!CmcdData} data The data object
  387.    * @param {boolean} useHeaders Send data via request headers
  388.    * @private
  389.    */
  390.   apply_(request, data = {}, useHeaders = this.config_.useHeaders) {
  391.     if (!this.config_.enabled) {
  392.       return;
  393.     }
  395.     // apply baseline data
  396.     Object.assign(data, this.createData_());
  398.     data.pr = this.playerInterface_.getPlaybackRate();
  400.     const isVideo = data.ot === shaka.util.CmcdManager.ObjectType.VIDEO ||
  401.         data.ot === shaka.util.CmcdManager.ObjectType.MUXED;
  403.     if (this.starved_ && isVideo) {
  404.       data.bs = true;
  405.       data.su = true;
  406.       this.starved_ = false;
  407.     }
  409.     if (data.su == null) {
  410.       data.su = this.buffering_;
  411.     }
  413.     const output = this.filterKeys_(data);
  415.     if (useHeaders) {
  416.       const headers = shaka.util.CmcdManager.toHeaders(output);
  417.       if (!Object.keys(headers).length) {
  418.         return;
  419.       }
  421.       Object.assign(request.headers, headers);
  422.     } else {
  423.       const query = shaka.util.CmcdManager.toQuery(output);
  424.       if (!query) {
  425.         return;
  426.       }
  428.       request.uris = request.uris.map((uri) => {
  429.         return shaka.util.CmcdManager.appendQueryToUri(uri, query);
  430.       });
  431.     }
  432.   }
  434.   /**
  435.    * Filter the CMCD data object to include only the keys specified in the
  436.    * configuration.
  437.    *
  438.    * @param {CmcdData} data
  439.    * @return {CmcdData}
  440.    * @private
  441.    */
  442.   filterKeys_(data) {
  443.     const includeKeys = this.config_.includeKeys;
  445.     if (!includeKeys.length) {
  446.       return data;
  447.     }
  449.     return Object.keys(data).reduce((acc, key) => {
  450.       if (includeKeys.includes(key)) {
  451.         acc[key] = data[key];
  452.       }
  453.       return acc;
  454.     }, {});
  455.   }
  457.   /**
  458.    * The CMCD object type.
  459.    *
  460.    * @param {shaka.extern.RequestContext} context
  461.    *   The request context
  462.    * @private
  463.    */
  464.   getObjectType_(context) {
  465.     if (context.type ===
  466.         shaka.net.NetworkingEngine.AdvancedRequestType.INIT_SEGMENT) {
  467.       return shaka.util.CmcdManager.ObjectType.INIT;
  468.     }
  470.     const stream = context.stream;
  472.     if (!stream) {
  473.       return undefined;
  474.     }
  476.     const type = stream.type;
  478.     if (type == 'video') {
  479.       if (stream.codecs && stream.codecs.includes(',')) {
  480.         return shaka.util.CmcdManager.ObjectType.MUXED;
  481.       }
  482.       return shaka.util.CmcdManager.ObjectType.VIDEO;
  483.     }
  485.     if (type == 'audio') {
  486.       return shaka.util.CmcdManager.ObjectType.AUDIO;
  487.     }
  489.     if (type == 'text') {
  490.       if (stream.mimeType === 'application/mp4') {
  491.         return shaka.util.CmcdManager.ObjectType.TIMED_TEXT;
  492.       }
  493.       return shaka.util.CmcdManager.ObjectType.CAPTION;
  494.     }
  496.     return undefined;
  497.   }
  499.   /**
  500.    * The CMCD object type from mimeType.
  501.    *
  502.    * @param {!string} mimeType
  503.    * @return {(shaka.util.CmcdManager.ObjectType|undefined)}
  504.    * @private
  505.    */
  506.   getObjectTypeFromMimeType_(mimeType) {
  507.     switch (mimeType.toLowerCase()) {
  508.       case 'audio/mp4':
  509.       case 'audio/webm':
  510.       case 'audio/ogg':
  511.       case 'audio/mpeg':
  512.       case 'audio/aac':
  513.       case 'audio/flac':
  514.       case 'audio/wav':
  515.         return shaka.util.CmcdManager.ObjectType.AUDIO;
  517.       case 'video/webm':
  518.       case 'video/mp4':
  519.       case 'video/mpeg':
  520.       case 'video/mp2t':
  521.         return shaka.util.CmcdManager.ObjectType.MUXED;
  523.       case 'application/x-mpegurl':
  524.       case 'application/vnd.apple.mpegurl':
  525.       case 'application/dash+xml':
  526.       case 'video/vnd.mpeg.dash.mpd':
  527.       case 'application/vnd.ms-sstr+xml':
  528.         return shaka.util.CmcdManager.ObjectType.MANIFEST;
  530.       default:
  531.         return undefined;
  532.     }
  533.   }
  535.   /**
  536.    * Get the buffer length for a media type in milliseconds
  537.    *
  538.    * @param {string} type
  539.    * @return {number}
  540.    * @private
  541.    */
  542.   getBufferLength_(type) {
  543.     const ranges = this.playerInterface_.getBufferedInfo()[type];
  545.     if (!ranges.length) {
  546.       return NaN;
  547.     }
  549.     const start = this.playerInterface_.getCurrentTime();
  550.     const range = ranges.find((r) => r.start <= start && r.end >= start);
  552.     if (!range) {
  553.       return NaN;
  554.     }
  556.     return (range.end - start) * 1000;
  557.   }
  559.   /**
  560.    * Get the remaining buffer length for a media type in milliseconds
  561.    *
  562.    * @param {string} type
  563.    * @return {number}
  564.    * @private
  565.    */
  566.   getRemainingBufferLength_(type) {
  567.     const ranges = this.playerInterface_.getBufferedInfo()[type];
  569.     if (!ranges.length) {
  570.       return 0;
  571.     }
  573.     const start = this.playerInterface_.getCurrentTime();
  574.     const range = ranges.find((r) => r.start <= start && r.end >= start);
  576.     if (!range) {
  577.       return 0;
  578.     }
  580.     return (range.end - start) * 1000;
  581.   }
  583.   /**
  584.    * Constructs a relative path from a URL
  585.    *
  586.    * @param {string} url
  587.    * @param {string} base
  588.    * @return {string}
  589.    * @private
  590.    */
  591.   urlToRelativePath_(url, base) {
  592.     const to = new URL(url);
  593.     const from = new URL(base);
  595.     if (to.origin !== from.origin) {
  596.       return url;
  597.     }
  599.     const toPath = to.pathname.split('/').slice(1);
  600.     const fromPath = from.pathname.split('/').slice(1, -1);
  602.     // remove common parents
  603.     while (toPath[0] === fromPath[0]) {
  604.       toPath.shift();
  605.       fromPath.shift();
  606.     }
  608.     // add back paths
  609.     while (fromPath.length) {
  610.       fromPath.shift();
  611.       toPath.unshift('..');
  612.     }
  614.     return toPath.join('/');
  615.   }
  617.   /**
  618.    * Calculate requested maximun throughput
  619.    *
  620.    * @param {shaka.extern.Stream} stream
  621.    * @param {shaka.media.SegmentReference} segment
  622.    * @return {number}
  623.    * @private
  624.    */
  625.   calculateRtp_(stream, segment) {
  626.     const playbackRate = this.playerInterface_.getPlaybackRate() || 1;
  627.     const currentBufferLevel =
  628.         this.getRemainingBufferLength_(stream.type) || 500;
  629.     const bandwidth = stream.bandwidth;
  630.     if (!bandwidth) {
  631.       return NaN;
  632.     }
  633.     const segmentDuration = segment.endTime - segment.startTime;
  634.     // Calculate file size in kilobits
  635.     const segmentSize = bandwidth * segmentDuration / 1000;
  636.     // Calculate time available to load file in seconds
  637.     const timeToLoad = (currentBufferLevel / playbackRate) / 1000;
  638.     // Calculate the exact bandwidth required
  639.     const minBandwidth = segmentSize / timeToLoad;
  640.     // Include a safety buffer
  641.     return minBandwidth * this.config_.rtpSafetyFactor;
  642.   }
  644.   /**
  645.    * Get the stream format
  646.    *
  647.    * @param {shaka.net.NetworkingEngine.AdvancedRequestType} type
  648.    *   The request's advanced type
  649.    * @return {(shaka.util.CmcdManager.StreamingFormat|undefined)}
  650.    * @private
  651.    */
  652.   getStreamFormat_(type) {
  653.     const AdvancedRequestType = shaka.net.NetworkingEngine.AdvancedRequestType;
  655.     switch (type) {
  656.       case AdvancedRequestType.MPD:
  657.         if (this.lowLatency_) {
  658.           return shaka.util.CmcdManager.StreamingFormat.LOW_LATENCY_DASH;
  659.         }
  660.         return shaka.util.CmcdManager.StreamingFormat.DASH;
  662.       case AdvancedRequestType.MASTER_PLAYLIST:
  663.       case AdvancedRequestType.MEDIA_PLAYLIST:
  664.         if (this.lowLatency_) {
  665.           return shaka.util.CmcdManager.StreamingFormat.LOW_LATENCY_HLS;
  666.         }
  667.         return shaka.util.CmcdManager.StreamingFormat.HLS;
  669.       case AdvancedRequestType.MSS:
  670.         return shaka.util.CmcdManager.StreamingFormat.SMOOTH;
  671.     }
  673.     return undefined;
  674.   }
  676.   /**
  677.    * Get the stream type
  678.    *
  679.    * @return {shaka.util.CmcdManager.StreamType}
  680.    * @private
  681.    */
  682.   getStreamType_() {
  683.     const isLive = this.playerInterface_.isLive();
  684.     if (isLive) {
  685.       return shaka.util.CmcdManager.StreamType.LIVE;
  686.     } else {
  687.       return shaka.util.CmcdManager.StreamType.VOD;
  688.     }
  689.   }
  691.   /**
  692.    * Get the highest bandwidth for a given type.
  693.    *
  694.    * @param {string} type
  695.    * @return {number}
  696.    * @private
  697.    */
  698.   getTopBandwidth_(type) {
  699.     const variants = this.playerInterface_.getVariantTracks();
  700.     if (!variants.length) {
  701.       return NaN;
  702.     }
  704.     let top = variants[0];
  706.     for (const variant of variants) {
  707.       if (variant.type === 'variant' && variant.bandwidth > top.bandwidth) {
  708.         top = variant;
  709.       }
  710.     }
  712.     const ObjectType = shaka.util.CmcdManager.ObjectType;
  714.     switch (type) {
  715.       case ObjectType.VIDEO:
  716.         return top.videoBandwidth || NaN;
  718.       case ObjectType.AUDIO:
  719.         return top.audioBandwidth || NaN;
  721.       default:
  722.         return top.bandwidth;
  723.     }
  724.   }
  726.   /**
  727.    * Serialize a CMCD data object according to the rules defined in the
  728.    * section 3.2 of
  729.    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
  730.    *
  731.    * @param {CmcdData} data The CMCD data object
  732.    * @return {string}
  733.    */
  734.   static serialize(data) {
  735.     const results = [];
  736.     const isValid = (value) =>
  737.       !Number.isNaN(value) && value != null && value !== '' && value !== false;
  738.     const toRounded = (value) => Math.round(value);
  739.     const toHundred = (value) => toRounded(value / 100) * 100;
  740.     const toUrlSafe = (value) => encodeURIComponent(value);
  741.     const formatters = {
  742.       br: toRounded,
  743.       d: toRounded,
  744.       bl: toHundred,
  745.       dl: toHundred,
  746.       mtp: toHundred,
  747.       nor: toUrlSafe,
  748.       rtp: toHundred,
  749.       tb: toRounded,
  750.     };
  752.     const keys = Object.keys(data || {}).sort();
  754.     for (const key of keys) {
  755.       let value = data[key];
  757.       // ignore invalid values
  758.       if (!isValid(value)) {
  759.         continue;
  760.       }
  762.       // Version should only be reported if not equal to 1.
  763.       if (key === 'v' && value === 1) {
  764.         continue;
  765.       }
  767.       // Playback rate should only be sent if not equal to 1.
  768.       if (key == 'pr' && value === 1) {
  769.         continue;
  770.       }
  772.       // Certain values require special formatting
  773.       const formatter = formatters[key];
  774.       if (formatter) {
  775.         value = formatter(value);
  776.       }
  778.       // Serialize the key/value pair
  779.       const type = typeof value;
  780.       let result;
  782.       if (type === 'string' && key !== 'ot' && key !== 'sf' && key !== 'st') {
  783.         result = `${key}=${JSON.stringify(value)}`;
  784.       } else if (type === 'boolean') {
  785.         result = key;
  786.       } else if (type === 'symbol') {
  787.         result = `${key}=${value.description}`;
  788.       } else {
  789.         result = `${key}=${value}`;
  790.       }
  792.       results.push(result);
  793.     }
  795.     return results.join(',');
  796.   }
  798.   /**
  799.    * Convert a CMCD data object to request headers according to the rules
  800.    * defined in the section 2.1 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 {!Object}
  805.    */
  806.   static toHeaders(data) {
  807.     const keys = Object.keys(data);
  808.     const headers = {};
  809.     const headerNames = ['Object', 'Request', 'Session', 'Status'];
  810.     const headerGroups = [{}, {}, {}, {}];
  811.     const headerMap = {
  812.       br: 0, d: 0, ot: 0, tb: 0,
  813.       bl: 1, dl: 1, mtp: 1, nor: 1, nrr: 1, su: 1,
  814.       cid: 2, pr: 2, sf: 2, sid: 2, st: 2, v: 2,
  815.       bs: 3, rtp: 3,
  816.     };
  818.     for (const key of keys) {
  819.       // Unmapped fields are mapped to the Request header
  820.       const index = (headerMap[key] != null) ? headerMap[key] : 1;
  821.       headerGroups[index][key] = data[key];
  822.     }
  824.     for (let i = 0; i < headerGroups.length; i++) {
  825.       const value = shaka.util.CmcdManager.serialize(headerGroups[i]);
  826.       if (value) {
  827.         headers[`CMCD-${headerNames[i]}`] = value;
  828.       }
  829.     }
  831.     return headers;
  832.   }
  834.   /**
  835.    * Convert a CMCD data object to query args according to the rules
  836.    * defined in the section 2.2 and 3.2 of
  837.    * [CTA-5004](https://cdn.cta.tech/cta/media/media/resources/standards/pdfs/cta-5004-final.pdf).
  838.    *
  839.    * @param {CmcdData} data The CMCD data object
  840.    * @return {string}
  841.    */
  842.   static toQuery(data) {
  843.     return shaka.util.CmcdManager.serialize(data);
  844.   }
  846.   /**
  847.    * Append query args to a uri.
  848.    *
  849.    * @param {string} uri
  850.    * @param {string} query
  851.    * @return {string}
  852.    */
  853.   static appendQueryToUri(uri, query) {
  854.     if (!query) {
  855.       return uri;
  856.     }
  858.     if (uri.includes('offline:')) {
  859.       return uri;
  860.     }
  862.     const url = new goog.Uri(uri);
  863.     url.getQueryData().set('CMCD', query);
  864.     return url.toString();
  865.   }
  866. };
  869. /**
  870.  * @typedef {{
  871.  *   getBandwidthEstimate: function():number,
  872.  *   getBufferedInfo: function():shaka.extern.BufferedInfo,
  873.  *   getCurrentTime: function():number,
  874.  *   getPlaybackRate: function():number,
  875.  *   getVariantTracks: function():Array.<shaka.extern.Track>,
  876.  *   isLive: function():boolean
  877.  * }}
  878.  *
  879.  * @property {function():number} getBandwidthEstimate
  880.  *   Get the estimated bandwidth in bits per second.
  881.  * @property {function():shaka.extern.BufferedInfo} getBufferedInfo
  882.  *   Get information about what the player has buffered.
  883.  * @property {function():number} getCurrentTime
  884.  *   Get the current time
  885.  * @property {function():number} getPlaybackRate
  886.  *   Get the playback rate
  887.  * @property {function():Array.<shaka.extern.Track>} getVariantTracks
  888.  *   Get the variant tracks
  889.  * @property {function():boolean} isLive
  890.  *   Get if the player is playing live content.
  891.  */
  892. shaka.util.CmcdManager.PlayerInterface;
  895. /**
  896.  * @enum {string}
  897.  */
  898. shaka.util.CmcdManager.ObjectType = {
  899.   MANIFEST: 'm',
  900.   AUDIO: 'a',
  901.   VIDEO: 'v',
  902.   MUXED: 'av',
  903.   INIT: 'i',
  904.   CAPTION: 'c',
  905.   TIMED_TEXT: 'tt',
  906.   KEY: 'k',
  907.   OTHER: 'o',
  908. };
  911. /**
  912.  * @enum {string}
  913.  */
  914. shaka.util.CmcdManager.StreamType = {
  915.   VOD: 'v',
  916.   LIVE: 'l',
  917. };
  920. /**
  921.  * @enum {string}
  922.  * @export
  923.  */
  924. shaka.util.CmcdManager.StreamingFormat = {
  925.   DASH: 'd',
  926.   LOW_LATENCY_DASH: 'ld',
  927.   HLS: 'h',
  928.   LOW_LATENCY_HLS: 'lh',
  929.   SMOOTH: 's',
  930.   OTHER: 'o',
  931. };
  934. /**
  935.  * The CMCD spec version
  936.  * @const {number}
  937.  */
  938. shaka.util.CmcdManager.Version = 1;