Source: lib/util/stream_utils.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.StreamUtils');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.text.TextEngine');
  12. goog.require('shaka.util.Functional');
  13. goog.require('shaka.util.LanguageUtils');
  14. goog.require('shaka.util.ManifestParserUtils');
  15. goog.require('shaka.util.MimeUtils');
  16. goog.require('shaka.util.MultiMap');
  17. goog.require('shaka.util.Platform');
  18. goog.requireType('shaka.media.DrmEngine');
  21. /**
  22.  * @summary A set of utility functions for dealing with Streams and Manifests.
  23.  */
  24. shaka.util.StreamUtils = class {
  25.   /**
  26.    * In case of multiple usable codecs, choose one based on lowest average
  27.    * bandwidth and filter out the rest.
  28.    * Also filters out variants that have too many audio channels.
  29.    * @param {!shaka.extern.Manifest} manifest
  30.    * @param {!Array.<string>} preferredVideoCodecs
  31.    * @param {!Array.<string>} preferredAudioCodecs
  32.    * @param {number} preferredAudioChannelCount
  33.    * @param {!Array.<string>} preferredDecodingAttributes
  34.    */
  35.   static chooseCodecsAndFilterManifest(manifest, preferredVideoCodecs,
  36.       preferredAudioCodecs, preferredAudioChannelCount,
  37.       preferredDecodingAttributes) {
  38.     const StreamUtils = shaka.util.StreamUtils;
  40.     let variants = manifest.variants;
  41.     // To start, choose the codecs based on configured preferences if available.
  42.     if (preferredVideoCodecs.length || preferredAudioCodecs.length) {
  43.       variants = StreamUtils.choosePreferredCodecs(variants,
  44.           preferredVideoCodecs, preferredAudioCodecs);
  45.     }
  47.     // Consider a subset of variants based on audio channel
  48.     // preferences.
  49.     // For some content (#1013), surround-sound variants will use a different
  50.     // codec than stereo variants, so it is important to choose codecs **after**
  51.     // considering the audio channel config.
  52.     variants = StreamUtils.filterVariantsByAudioChannelCount(
  53.         variants, preferredAudioChannelCount);
  55.     // Now organize variants into buckets by codecs.
  56.     /** @type {!shaka.util.MultiMap.<shaka.extern.Variant>} */
  57.     let variantsByCodecs = StreamUtils.getVariantsByCodecs_(variants);
  58.     variantsByCodecs = StreamUtils.filterVariantsByDensity_(variantsByCodecs);
  60.     const bestCodecs = StreamUtils.chooseCodecsByDecodingAttributes_(
  61.         variantsByCodecs, preferredDecodingAttributes);
  63.     // Filter out any variants that don't match, forcing AbrManager to choose
  64.     // from a single video codec and a single audio codec possible.
  65.     manifest.variants = manifest.variants.filter((variant) => {
  66.       const codecs = StreamUtils.getVariantCodecs_(variant);
  67.       if (codecs == bestCodecs) {
  68.         return true;
  69.       }
  71.       shaka.log.debug('Dropping Variant (better codec available)', variant);
  72.       return false;
  73.     });
  74.   }
  76.   /**
  77.   * Get variants by codecs.
  78.   *
  79.   * @param {!Array<shaka.extern.Variant>} variants
  80.   * @return {!shaka.util.MultiMap.<shaka.extern.Variant>}
  81.   * @private
  82.   */
  83.   static getVariantsByCodecs_(variants) {
  84.     const variantsByCodecs = new shaka.util.MultiMap();
  85.     for (const variant of variants) {
  86.       const variantCodecs = shaka.util.StreamUtils.getVariantCodecs_(variant);
  87.       variantsByCodecs.push(variantCodecs, variant);
  88.     }
  90.     return variantsByCodecs;
  91.   }
  93.   /**
  94.   * Filters variants by density.
  95.   * Get variants by codecs map with the max density where all codecs are
  96.   * present.
  97.   *
  98.   * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
  99.   * @return {!shaka.util.MultiMap.<shaka.extern.Variant>}
  100.   * @private
  101.   */
  102.   static filterVariantsByDensity_(variantsByCodecs) {
  103.     let maxDensity = 0;
  104.     const codecGroupsByDensity = new Map();
  105.     const countCodecs = variantsByCodecs.size();
  107.     variantsByCodecs.forEach((codecs, variants) => {
  108.       for (const variant of variants) {
  109.         const video = variant.video;
  110.         if (!video || !video.width || !video.height) {
  111.           continue;
  112.         }
  114.         const density = video.width * video.height * (video.frameRate || 1);
  115.         if (!codecGroupsByDensity.has(density)) {
  116.           codecGroupsByDensity.set(density, new shaka.util.MultiMap());
  117.         }
  119.         /** @type {!shaka.util.MultiMap.<shaka.extern.Variant>} */
  120.         const group = codecGroupsByDensity.get(density);
  121.         group.push(codecs, variant);
  123.         // We want to look at the groups in which all codecs are present.
  124.         // Take the max density from those groups where all codecs are present.
  125.         // Later, we will compare bandwidth numbers only within this group.
  126.         // Effectively, only the bandwidth differences in the highest-res and
  127.         // highest-framerate content will matter in choosing a codec.
  128.         if (group.size() === countCodecs) {
  129.           maxDensity = Math.max(maxDensity, density);
  130.         }
  131.       }
  132.     });
  134.     return maxDensity ? codecGroupsByDensity.get(maxDensity) : variantsByCodecs;
  135.   }
  137.   /**
  138.    * Choose the codecs by configured preferred audio and video codecs.
  139.    *
  140.    * @param {!Array<shaka.extern.Variant>} variants
  141.    * @param {!Array.<string>} preferredVideoCodecs
  142.    * @param {!Array.<string>} preferredAudioCodecs
  143.    * @return {!Array<shaka.extern.Variant>}
  144.    */
  145.   static choosePreferredCodecs(variants, preferredVideoCodecs,
  146.       preferredAudioCodecs) {
  147.     let subset = variants;
  148.     for (const videoCodec of preferredVideoCodecs) {
  149.       const filtered = subset.filter((variant) => {
  150.         return variant.video && variant.video.codecs.startsWith(videoCodec);
  151.       });
  152.       if (filtered.length) {
  153.         subset = filtered;
  154.         break;
  155.       }
  156.     }
  158.     for (const audioCodec of preferredAudioCodecs) {
  159.       const filtered = subset.filter((variant) => {
  160.         return variant.audio && variant.audio.codecs.startsWith(audioCodec);
  161.       });
  162.       if (filtered.length) {
  163.         subset = filtered;
  164.         break;
  165.       }
  166.     }
  167.     return subset;
  168.   }
  170.   /**
  171.    * Choose the codecs by configured preferred decoding attributes.
  172.    *
  173.    * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
  174.    * @param {!Array.<string>} attributes
  175.    * @return {string}
  176.    * @private
  177.    */
  178.   static chooseCodecsByDecodingAttributes_(variantsByCodecs, attributes) {
  179.     const StreamUtils = shaka.util.StreamUtils;
  181.     for (const attribute of attributes) {
  182.       if (attribute == StreamUtils.DecodingAttributes.SMOOTH ||
  183.           attribute == StreamUtils.DecodingAttributes.POWER) {
  184.         variantsByCodecs = StreamUtils.chooseCodecsByMediaCapabilitiesInfo_(
  185.             variantsByCodecs, attribute);
  186.         // If we only have one smooth or powerEfficient codecs, choose it as the
  187.         // best codecs.
  188.         if (variantsByCodecs.size() == 1) {
  189.           return variantsByCodecs.keys()[0];
  190.         }
  191.       } else if (attribute == StreamUtils.DecodingAttributes.BANDWIDTH) {
  192.         return StreamUtils.findCodecsByLowestBandwidth_(variantsByCodecs);
  193.       }
  194.     }
  195.     // If there's no configured decoding preferences, or we have multiple codecs
  196.     // that meets the configured decoding preferences, choose the one with
  197.     // the lowest bandwidth.
  198.     return StreamUtils.findCodecsByLowestBandwidth_(variantsByCodecs);
  199.   }
  201.   /**
  202.    * Choose the best codecs by configured preferred MediaCapabilitiesInfo
  203.    * attributes.
  204.    *
  205.    * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
  206.    * @param {string} attribute
  207.    * @return {!shaka.util.MultiMap.<shaka.extern.Variant>}
  208.    * @private
  209.    */
  210.   static chooseCodecsByMediaCapabilitiesInfo_(variantsByCodecs, attribute) {
  211.     let highestScore = 0;
  212.     const bestVariantsByCodecs = new shaka.util.MultiMap();
  213.     variantsByCodecs.forEach((codecs, variants) => {
  214.       let sum = 0;
  215.       let num = 0;
  217.       for (const variant of variants) {
  218.         if (variant.decodingInfos.length) {
  219.           sum += variant.decodingInfos[0][attribute] ? 1 : 0;
  220.           num++;
  221.         }
  222.       }
  224.       const averageScore = sum / num;
  225.       shaka.log.debug('codecs', codecs, 'avg', attribute, averageScore);
  227.       if (averageScore > highestScore) {
  228.         bestVariantsByCodecs.clear();
  229.         bestVariantsByCodecs.push(codecs, variants);
  230.         highestScore = averageScore;
  231.       } else if (averageScore == highestScore) {
  232.         bestVariantsByCodecs.push(codecs, variants);
  233.       }
  234.     });
  235.     return bestVariantsByCodecs;
  236.   }
  238.   /**
  239.    * Find the lowest-bandwidth (best) codecs.
  240.    * Compute the average bandwidth for each group of variants.
  241.    *
  242.    * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
  243.    * @return {string}
  244.    * @private
  245.    */
  246.   static findCodecsByLowestBandwidth_(variantsByCodecs) {
  247.     let bestCodecs = '';
  248.     let lowestAverageBandwidth = Infinity;
  250.     variantsByCodecs.forEach((codecs, variants) => {
  251.       let sum = 0;
  252.       let num = 0;
  253.       for (const variant of variants) {
  254.         sum += variant.bandwidth || 0;
  255.         ++num;
  256.       }
  258.       const averageBandwidth = sum / num;
  259.       shaka.log.debug('codecs', codecs, 'avg bandwidth', averageBandwidth);
  261.       if (averageBandwidth < lowestAverageBandwidth) {
  262.         bestCodecs = codecs;
  263.         lowestAverageBandwidth = averageBandwidth;
  264.       }
  265.     });
  267.     goog.asserts.assert(bestCodecs !== '', 'Should have chosen codecs!');
  268.     goog.asserts.assert(!isNaN(lowestAverageBandwidth),
  269.         'Bandwidth should be a number!');
  271.     return bestCodecs;
  272.   }
  274.   /**
  275.    * Get a string representing all codecs used in a variant.
  276.    *
  277.    * @param {!shaka.extern.Variant} variant
  278.    * @return {string}
  279.    * @private
  280.    */
  281.   static getVariantCodecs_(variant) {
  282.     // Only consider the base of the codec string.  For example, these should
  283.     // both be considered the same codec: avc1.42c01e, avc1.4d401f
  284.     let baseVideoCodec = '';
  285.     if (variant.video) {
  286.       baseVideoCodec = shaka.util.MimeUtils.getCodecBase(variant.video.codecs);
  287.     }
  289.     let baseAudioCodec = '';
  290.     if (variant.audio) {
  291.       baseAudioCodec = shaka.util.MimeUtils.getCodecBase(variant.audio.codecs);
  292.     }
  294.     return baseVideoCodec + '-' + baseAudioCodec;
  295.   }
  297.   /**
  298.    * Filter the variants in |manifest| to only include the variants that meet
  299.    * the given restrictions.
  300.    *
  301.    * @param {!shaka.extern.Manifest} manifest
  302.    * @param {shaka.extern.Restrictions} restrictions
  303.    * @param {{width: number, height:number}} maxHwResolution
  304.    */
  305.   static filterByRestrictions(manifest, restrictions, maxHwResolution) {
  306.     manifest.variants = manifest.variants.filter((variant) => {
  307.       return shaka.util.StreamUtils.meetsRestrictions(
  308.           variant, restrictions, maxHwResolution);
  309.     });
  310.   }
  312.   /**
  313.    * @param {shaka.extern.Variant} variant
  314.    * @param {shaka.extern.Restrictions} restrictions
  315.    *   Configured restrictions from the user.
  316.    * @param {{width: number, height: number}} maxHwRes
  317.    *   The maximum resolution the hardware can handle.
  318.    *   This is applied separately from user restrictions because the setting
  319.    *   should not be easily replaced by the user's configuration.
  320.    * @return {boolean}
  321.    */
  322.   static meetsRestrictions(variant, restrictions, maxHwRes) {
  323.     /** @type {function(number, number, number):boolean} */
  324.     const inRange = (x, min, max) => {
  325.       return x >= min && x <= max;
  326.     };
  328.     const video = variant.video;
  330.     // |video.width| and |video.height| can be undefined, which breaks
  331.     // the math, so make sure they are there first.
  332.     if (video && video.width && video.height) {
  333.       if (!inRange(video.width,
  334.           restrictions.minWidth,
  335.           Math.min(restrictions.maxWidth, maxHwRes.width))) {
  336.         return false;
  337.       }
  339.       if (!inRange(video.height,
  340.           restrictions.minHeight,
  341.           Math.min(restrictions.maxHeight, maxHwRes.height))) {
  342.         return false;
  343.       }
  345.       if (!inRange(video.width * video.height,
  346.           restrictions.minPixels,
  347.           restrictions.maxPixels)) {
  348.         return false;
  349.       }
  350.     }
  352.     // |variant.frameRate| can be undefined, which breaks
  353.     // the math, so make sure they are there first.
  354.     if (variant && variant.video && variant.video.frameRate) {
  355.       if (!inRange(variant.video.frameRate,
  356.           restrictions.minFrameRate,
  357.           restrictions.maxFrameRate)) {
  358.         return false;
  359.       }
  360.     }
  362.     if (!inRange(variant.bandwidth,
  363.         restrictions.minBandwidth,
  364.         restrictions.maxBandwidth)) {
  365.       return false;
  366.     }
  368.     return true;
  369.   }
  372.   /**
  373.    * @param {!Array.<shaka.extern.Variant>} variants
  374.    * @param {shaka.extern.Restrictions} restrictions
  375.    * @param {{width: number, height: number}} maxHwRes
  376.    * @return {boolean} Whether the tracks changed.
  377.    */
  378.   static applyRestrictions(variants, restrictions, maxHwRes) {
  379.     let tracksChanged = false;
  381.     for (const variant of variants) {
  382.       const originalAllowed = variant.allowedByApplication;
  383.       variant.allowedByApplication = shaka.util.StreamUtils.meetsRestrictions(
  384.           variant, restrictions, maxHwRes);
  386.       if (originalAllowed != variant.allowedByApplication) {
  387.         tracksChanged = true;
  388.       }
  389.     }
  391.     return tracksChanged;
  392.   }
  395.   /**
  396.    * Alters the given Manifest to filter out any unplayable streams.
  397.    *
  398.    * @param {shaka.media.DrmEngine} drmEngine
  399.    * @param {?shaka.extern.Variant} currentVariant
  400.    * @param {shaka.extern.Manifest} manifest
  401.    */
  402.   static async filterManifest(
  403.       drmEngine, currentVariant, manifest) {
  404.     await shaka.util.StreamUtils.filterManifestByMediaCapabilities(manifest,
  405.         manifest.offlineSessionIds.length > 0);
  406.     shaka.util.StreamUtils.filterManifestByCurrentVariant(
  407.         currentVariant, manifest);
  408.     shaka.util.StreamUtils.filterTextStreams_(manifest);
  409.     shaka.util.StreamUtils.filterImageStreams_(manifest);
  410.   }
  413.   /**
  414.    * Alters the given Manifest to filter out any streams unsupported by the
  415.    * platform via MediaCapabilities.decodingInfo() API.
  416.    *
  417.    * @param {shaka.extern.Manifest} manifest
  418.    * @param {boolean} usePersistentLicenses
  419.    */
  420.   static async filterManifestByMediaCapabilities(
  421.       manifest, usePersistentLicenses) {
  422.     goog.asserts.assert(window.shakaMediaCapabilities,
  423.         'MediaCapabilities should be valid.');
  425.     await shaka.util.StreamUtils.getDecodingInfosForVariants(
  426.         manifest.variants, usePersistentLicenses, /* srcEquals= */ false);
  427.     manifest.variants = manifest.variants.filter((variant) => {
  428.       const video = variant.video;
  429.       // See: https://github.com/google/shaka-player/issues/3380
  430.       if (shaka.util.Platform.isXboxOne() && video &&
  431.           ((video.width && video.width > 1920) ||
  432.           (video.height && video.height > 1080)) &&
  433.           video.codecs.includes('avc1.')) {
  434.         shaka.log.debug('Dropping variant - not compatible with platform',
  435.             shaka.util.StreamUtils.getVariantSummaryString_(variant));
  436.         return false;
  437.       }
  439.       const supported = variant.decodingInfos.some((decodingInfo) => {
  440.         return decodingInfo.supported;
  441.       });
  442.       // Filter out all unsupported variants.
  443.       if (!supported) {
  444.         shaka.log.debug('Dropping variant - not compatible with platform',
  445.             shaka.util.StreamUtils.getVariantSummaryString_(variant));
  446.       }
  447.       return supported;
  448.     });
  449.   }
  452.   /**
  453.    * Get the decodingInfo results of the variants via MediaCapabilities.
  454.    * This should be called after the DrmEngine is created and configured, and
  455.    * before DrmEngine sets the mediaKeys.
  456.    *
  457.    * @param {!Array.<shaka.extern.Variant>} variants
  458.    * @param {boolean} usePersistentLicenses
  459.    * @param {boolean} srcEquals
  460.    * @exportDoc
  461.    */
  462.   static async getDecodingInfosForVariants(variants, usePersistentLicenses,
  463.       srcEquals) {
  464.     const gotDecodingInfo = variants.some((variant) =>
  465.       variant.decodingInfos.length);
  466.     if (gotDecodingInfo) {
  467.       shaka.log.debug('Already got the variants\' decodingInfo.');
  468.       return;
  469.     }
  471.     const mediaCapabilities = window.shakaMediaCapabilities;
  473.     const operations = [];
  474.     const getVariantDecodingInfos = (async (variant, decodingConfig) => {
  475.       try {
  476.         const result = await mediaCapabilities.decodingInfo(decodingConfig);
  477.         variant.decodingInfos.push(result);
  478.       } catch (e) {
  479.         shaka.log.info('MediaCapabilities.decodingInfo() failed.',
  480.             JSON.stringify(decodingConfig), e);
  481.       }
  482.     });
  484.     for (const variant of variants) {
  485.       /** @type {!Array.<!MediaDecodingConfiguration>} */
  486.       const decodingConfigs = shaka.util.StreamUtils.getDecodingConfigs_(
  487.           variant, usePersistentLicenses, srcEquals);
  489.       for (const config of decodingConfigs) {
  490.         operations.push(getVariantDecodingInfos(variant, config));
  491.       }
  492.     }
  493.     await Promise.all(operations);
  494.   }
  497.   /**
  498.    * Generate a MediaDecodingConfiguration object to get the decodingInfo
  499.    * results for each variant.
  500.    * @param {!shaka.extern.Variant} variant
  501.    * @param {boolean} usePersistentLicenses
  502.    * @param {boolean} srcEquals
  503.    * @return {!Array.<!MediaDecodingConfiguration>}
  504.    * @private
  505.    */
  506.   static getDecodingConfigs_(variant, usePersistentLicenses, srcEquals) {
  507.     const audio = variant.audio;
  508.     const video = variant.video;
  509.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  511.     /** @type {!MediaDecodingConfiguration} */
  512.     const mediaDecodingConfig = {
  513.       type: srcEquals ? 'file' : 'media-source',
  514.     };
  516.     if (video) {
  517.       let videoCodecs = video.codecs;
  518.       // For multiplexed streams with audio+video codecs, the config should have
  519.       // AudioConfiguration and VideoConfiguration.
  520.       if (video.codecs.includes(',')) {
  521.         const allCodecs = video.codecs.split(',');
  522.         videoCodecs = shaka.util.ManifestParserUtils.guessCodecs(
  523.             ContentType.VIDEO, allCodecs);
  524.         videoCodecs = shaka.util.StreamUtils.patchVp9(videoCodecs);
  525.         const audioCodecs = shaka.util.ManifestParserUtils.guessCodecs(
  526.             ContentType.AUDIO, allCodecs);
  528.         const audioFullType = shaka.util.MimeUtils.getFullOrConvertedType(
  529.             video.mimeType, audioCodecs, ContentType.AUDIO);
  530.         mediaDecodingConfig.audio = {
  531.           contentType: audioFullType,
  532.           channels: 2,
  533.           bitrate: variant.bandwidth || 1,
  534.           samplerate: 1,
  535.           spatialRendering: false,
  536.         };
  537.       }
  538.       videoCodecs = shaka.util.StreamUtils.patchVp9(videoCodecs);
  539.       const fullType = shaka.util.MimeUtils.getFullOrConvertedType(
  540.           video.mimeType, videoCodecs, ContentType.VIDEO);
  541.       // VideoConfiguration
  542.       mediaDecodingConfig.video = {
  543.         contentType: fullType,
  544.         width: video.width || 1,
  545.         height: video.height || 1,
  546.         bitrate: video.bandwidth || variant.bandwidth || 1,
  547.         // framerate must be greater than 0, otherwise the config is invalid.
  548.         framerate: video.frameRate || 1,
  549.       };
  550.       if (video.hdr) {
  551.         switch (video.hdr) {
  552.           case 'SDR':
  553.             mediaDecodingConfig.video.transferFunction = 'srgb';
  554.             break;
  555.           case 'PQ':
  556.             mediaDecodingConfig.video.transferFunction = 'pq';
  557.             break;
  558.           case 'HLG':
  559.             mediaDecodingConfig.video.transferFunction = 'hlg';
  560.             break;
  561.         }
  562.       }
  563.     }
  564.     if (audio) {
  565.       // Some Tizen devices seem to misreport AC-3 support, but correctly
  566.       // report EC-3 support.  So query EC-3 as a fallback for AC-3.
  567.       // See https://github.com/google/shaka-player/issues/2989 for details.
  568.       const codecs =
  569.           (audio.codecs.toLowerCase() == 'ac-3' &&
  570.           shaka.util.Platform.isTizen()) ? 'ec-3' : audio.codecs;
  571.       const fullType = shaka.util.MimeUtils.getFullOrConvertedType(
  572.           audio.mimeType, codecs, ContentType.AUDIO);
  574.       // AudioConfiguration
  575.       mediaDecodingConfig.audio = {
  576.         contentType: fullType,
  577.         channels: audio.channelsCount || 2,
  578.         bitrate: audio.bandwidth || variant.bandwidth || 1,
  579.         samplerate: audio.audioSamplingRate || 1,
  580.         spatialRendering: audio.spatialAudio,
  581.       };
  582.     }
  584.     const videoDrmInfos = variant.video ? variant.video.drmInfos : [];
  585.     const audioDrmInfos = variant.audio ? variant.audio.drmInfos : [];
  586.     const allDrmInfos = videoDrmInfos.concat(audioDrmInfos);
  588.     // Return a list containing the mediaDecodingConfig for unencrypted variant.
  589.     if (!allDrmInfos.length) {
  590.       return [mediaDecodingConfig];
  591.     }
  593.     // A list of MediaDecodingConfiguration objects created for the variant.
  594.     const configs = [];
  596.     // Get all the drm info so that we can avoid using nested loops when we
  597.     // just need the drm info.
  598.     const drmInfoByKeySystems = new Map();
  599.     for (const info of allDrmInfos) {
  600.       if (!drmInfoByKeySystems.get(info.keySystem)) {
  601.         drmInfoByKeySystems.set(info.keySystem, []);
  602.       }
  603.       drmInfoByKeySystems.get(info.keySystem).push(info);
  604.     }
  606.     const persistentState =
  607.         usePersistentLicenses ? 'required' : 'optional';
  608.     const sessionTypes =
  609.         usePersistentLicenses ? ['persistent-license'] : ['temporary'];
  611.     for (const keySystem of drmInfoByKeySystems.keys()) {
  612.       // Create a copy of the mediaDecodingConfig.
  613.       const config = /** @type {!MediaDecodingConfiguration} */
  614.           (Object.assign({}, mediaDecodingConfig));
  616.       const drmInfos = drmInfoByKeySystems.get(keySystem);
  618.       /** @type {!MediaCapabilitiesKeySystemConfiguration} */
  619.       const keySystemConfig = {
  620.         keySystem: keySystem,
  621.         initDataType: 'cenc',
  622.         persistentState: persistentState,
  623.         distinctiveIdentifier: 'optional',
  624.         sessionTypes: sessionTypes,
  625.       };
  627.       for (const info of drmInfos) {
  628.         if (info.initData && info.initData.length) {
  629.           const initDataTypes = new Set();
  630.           for (const initData of info.initData) {
  631.             initDataTypes.add(initData.initDataType);
  632.           }
  633.           if (initDataTypes.size > 1) {
  634.             shaka.log.v2('DrmInfo contains more than one initDataType,',
  635.                 'and we use the initDataType of the first initData.',
  636.                 info);
  637.           }
  638.           keySystemConfig.initDataType = info.initData[0].initDataType;
  639.         }
  641.         if (info.distinctiveIdentifierRequired) {
  642.           keySystemConfig.distinctiveIdentifier = 'required';
  643.         }
  644.         if (info.persistentStateRequired) {
  645.           keySystemConfig.persistentState = 'required';
  646.         }
  647.         if (info.sessionType) {
  648.           keySystemConfig.sessionTypes = [info.sessionType];
  649.         }
  651.         if (audio) {
  652.           if (!keySystemConfig.audio) {
  653.             // KeySystemTrackConfiguration
  654.             keySystemConfig.audio = {
  655.               robustness: info.audioRobustness,
  656.             };
  657.           } else {
  658.             keySystemConfig.audio.robustness =
  659.                 keySystemConfig.audio.robustness || info.audioRobustness;
  660.           }
  661.         }
  663.         if (video) {
  664.           if (!keySystemConfig.video) {
  665.             // KeySystemTrackConfiguration
  666.             keySystemConfig.video = {
  667.               robustness: info.videoRobustness,
  668.             };
  669.           } else {
  670.             keySystemConfig.video.robustness =
  671.                 keySystemConfig.video.robustness || info.videoRobustness;
  672.           }
  673.         }
  674.       }
  675.       config.keySystemConfiguration = keySystemConfig;
  676.       configs.push(config);
  677.     }
  678.     return configs;
  679.   }
  681.   /**
  682.    * MediaCapabilities supports 'vp09...' codecs, but not 'vp9'. Translate vp9
  683.    * codec strings into 'vp09...', to allow such content to play with
  684.    * mediaCapabilities enabled.
  685.    *
  686.    * @param {string} codec
  687.    * @return {string}
  688.    */
  689.   static patchVp9(codec) {
  690.     if (codec == 'vp9') {
  691.       return 'vp09.00.10.08';
  692.     }
  693.     return codec;
  694.   }
  697.   /**
  698.    * Alters the given Manifest to filter out any streams uncompatible with the
  699.    * current variant.
  700.    *
  701.    * @param {?shaka.extern.Variant} currentVariant
  702.    * @param {shaka.extern.Manifest} manifest
  703.    */
  704.   static filterManifestByCurrentVariant(currentVariant, manifest) {
  705.     const StreamUtils = shaka.util.StreamUtils;
  706.     manifest.variants = manifest.variants.filter((variant) => {
  707.       const audio = variant.audio;
  708.       const video = variant.video;
  709.       if (audio && currentVariant && currentVariant.audio) {
  710.         if (!StreamUtils.areStreamsCompatible_(audio, currentVariant.audio)) {
  711.           shaka.log.debug('Droping variant - not compatible with active audio',
  712.               'active audio',
  713.               StreamUtils.getStreamSummaryString_(currentVariant.audio),
  714.               'variant.audio',
  715.               StreamUtils.getStreamSummaryString_(audio));
  716.           return false;
  717.         }
  718.       }
  720.       if (video && currentVariant && currentVariant.video) {
  721.         if (!StreamUtils.areStreamsCompatible_(video, currentVariant.video)) {
  722.           shaka.log.debug('Droping variant - not compatible with active video',
  723.               'active video',
  724.               StreamUtils.getStreamSummaryString_(currentVariant.video),
  725.               'variant.video',
  726.               StreamUtils.getStreamSummaryString_(video));
  727.           return false;
  728.         }
  729.       }
  731.       return true;
  732.     });
  733.   }
  735.   /**
  736.    * Alters the given Manifest to filter out any unsupported text streams.
  737.    *
  738.    * @param {shaka.extern.Manifest} manifest
  739.    * @private
  740.    */
  741.   static filterTextStreams_(manifest) {
  742.     // Filter text streams.
  743.     manifest.textStreams = manifest.textStreams.filter((stream) => {
  744.       const fullMimeType = shaka.util.MimeUtils.getFullType(
  745.           stream.mimeType, stream.codecs);
  746.       const keep = shaka.text.TextEngine.isTypeSupported(fullMimeType);
  748.       if (!keep) {
  749.         shaka.log.debug('Dropping text stream. Is not supported by the ' +
  750.                         'platform.', stream);
  751.       }
  753.       return keep;
  754.     });
  755.   }
  758.   /**
  759.    * Alters the given Manifest to filter out any unsupported image streams.
  760.    *
  761.    * @param {shaka.extern.Manifest} manifest
  762.    * @private
  763.    */
  764.   static filterImageStreams_(manifest) {
  765.     // Filter image streams.
  766.     manifest.imageStreams = manifest.imageStreams.filter((stream) => {
  767.       // TODO: re-examine this and avoid allow-listing the MIME types we can
  768.       // accept.
  769.       const validMimeTypes = [
  770.         'image/svg+xml',
  771.         'image/png',
  772.         'image/jpeg',
  773.       ];
  774.       const Platform = shaka.util.Platform;
  775.       // Add webp support to popular platforms that support it.
  776.       const webpSupport = Platform.isWebOS() ||
  777.                           Platform.isTizen() ||
  778.                           Platform.isChromecast();
  779.       if (webpSupport) {
  780.         validMimeTypes.push('image/webp');
  781.       }
  782.       // TODO: add support to image/webp and image/avif
  783.       const keep = validMimeTypes.includes(stream.mimeType);
  785.       if (!keep) {
  786.         shaka.log.debug('Dropping image stream. Is not supported by the ' +
  787.                         'platform.', stream);
  788.       }
  790.       return keep;
  791.     });
  792.   }
  795.   /**
  796.    * @param {shaka.extern.Stream} s0
  797.    * @param {shaka.extern.Stream} s1
  798.    * @return {boolean}
  799.    * @private
  800.    */
  801.   static areStreamsCompatible_(s0, s1) {
  802.     // Basic mime types and basic codecs need to match.
  803.     // For example, we can't adapt between WebM and MP4,
  804.     // nor can we adapt between mp4a.* to ec-3.
  805.     // We can switch between text types on the fly,
  806.     // so don't run this check on text.
  807.     if (s0.mimeType != s1.mimeType) {
  808.       return false;
  809.     }
  811.     if (s0.codecs.split('.')[0] != s1.codecs.split('.')[0]) {
  812.       return false;
  813.     }
  815.     return true;
  816.   }
  819.   /**
  820.    * @param {shaka.extern.Variant} variant
  821.    * @return {shaka.extern.Track}
  822.    */
  823.   static variantToTrack(variant) {
  824.     /** @type {?shaka.extern.Stream} */
  825.     const audio = variant.audio;
  826.     /** @type {?shaka.extern.Stream} */
  827.     const video = variant.video;
  829.     /** @type {?string} */
  830.     const audioCodec = audio ? audio.codecs : null;
  831.     /** @type {?string} */
  832.     const videoCodec = video ? video.codecs : null;
  834.     /** @type {!Array.<string>} */
  835.     const codecs = [];
  836.     if (videoCodec) {
  837.       codecs.push(videoCodec);
  838.     }
  839.     if (audioCodec) {
  840.       codecs.push(audioCodec);
  841.     }
  843.     /** @type {!Array.<string>} */
  844.     const mimeTypes = [];
  845.     if (video) {
  846.       mimeTypes.push(video.mimeType);
  847.     }
  848.     if (audio) {
  849.       mimeTypes.push(audio.mimeType);
  850.     }
  851.     /** @type {?string} */
  852.     const mimeType = mimeTypes[0] || null;
  854.     /** @type {!Array.<string>} */
  855.     const kinds = [];
  856.     if (audio) {
  857.       kinds.push(audio.kind);
  858.     }
  859.     if (video) {
  860.       kinds.push(video.kind);
  861.     }
  862.     /** @type {?string} */
  863.     const kind = kinds[0] || null;
  865.     /** @type {!Set.<string>} */
  866.     const roles = new Set();
  867.     if (audio) {
  868.       for (const role of audio.roles) {
  869.         roles.add(role);
  870.       }
  871.     }
  872.     if (video) {
  873.       for (const role of video.roles) {
  874.         roles.add(role);
  875.       }
  876.     }
  878.     /** @type {shaka.extern.Track} */
  879.     const track = {
  880.       id: variant.id,
  881.       active: false,
  882.       type: 'variant',
  883.       bandwidth: variant.bandwidth,
  884.       language: variant.language,
  885.       label: null,
  886.       kind: kind,
  887.       width: null,
  888.       height: null,
  889.       frameRate: null,
  890.       pixelAspectRatio: null,
  891.       hdr: null,
  892.       mimeType: mimeType,
  893.       codecs: codecs.join(', '),
  894.       audioCodec: audioCodec,
  895.       videoCodec: videoCodec,
  896.       primary: variant.primary,
  897.       roles: Array.from(roles),
  898.       audioRoles: null,
  899.       forced: false,
  900.       videoId: null,
  901.       audioId: null,
  902.       channelsCount: null,
  903.       audioSamplingRate: null,
  904.       spatialAudio: false,
  905.       tilesLayout: null,
  906.       audioBandwidth: null,
  907.       videoBandwidth: null,
  908.       originalVideoId: null,
  909.       originalAudioId: null,
  910.       originalTextId: null,
  911.       originalImageId: null,
  912.     };
  914.     if (video) {
  915.       track.videoId = video.id;
  916.       track.originalVideoId = video.originalId;
  917.       track.width = video.width || null;
  918.       track.height = video.height || null;
  919.       track.frameRate = video.frameRate || null;
  920.       track.pixelAspectRatio = video.pixelAspectRatio || null;
  921.       track.videoBandwidth = video.bandwidth || null;
  922.     }
  924.     if (audio) {
  925.       track.audioId = audio.id;
  926.       track.originalAudioId = audio.originalId;
  927.       track.channelsCount = audio.channelsCount;
  928.       track.audioSamplingRate = audio.audioSamplingRate;
  929.       track.audioBandwidth = audio.bandwidth || null;
  930.       track.label = audio.label;
  931.       track.audioRoles = audio.roles;
  932.     }
  934.     return track;
  935.   }
  938.   /**
  939.    * @param {shaka.extern.Stream} stream
  940.    * @return {shaka.extern.Track}
  941.    */
  942.   static textStreamToTrack(stream) {
  943.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  945.     /** @type {shaka.extern.Track} */
  946.     const track = {
  947.       id: stream.id,
  948.       active: false,
  949.       type: ContentType.TEXT,
  950.       bandwidth: 0,
  951.       language: stream.language,
  952.       label: stream.label,
  953.       kind: stream.kind || null,
  954.       width: null,
  955.       height: null,
  956.       frameRate: null,
  957.       pixelAspectRatio: null,
  958.       hdr: null,
  959.       mimeType: stream.mimeType,
  960.       codecs: stream.codecs || null,
  961.       audioCodec: null,
  962.       videoCodec: null,
  963.       primary: stream.primary,
  964.       roles: stream.roles,
  965.       audioRoles: null,
  966.       forced: stream.forced,
  967.       videoId: null,
  968.       audioId: null,
  969.       channelsCount: null,
  970.       audioSamplingRate: null,
  971.       spatialAudio: false,
  972.       tilesLayout: null,
  973.       audioBandwidth: null,
  974.       videoBandwidth: null,
  975.       originalVideoId: null,
  976.       originalAudioId: null,
  977.       originalTextId: stream.originalId,
  978.       originalImageId: null,
  979.     };
  981.     return track;
  982.   }
  985.   /**
  986.    * @param {shaka.extern.Stream} stream
  987.    * @return {shaka.extern.Track}
  988.    */
  989.   static imageStreamToTrack(stream) {
  990.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  992.     /** @type {shaka.extern.Track} */
  993.     const track = {
  994.       id: stream.id,
  995.       active: false,
  996.       type: ContentType.IMAGE,
  997.       bandwidth: stream.bandwidth || 0,
  998.       language: '',
  999.       label: null,
  1000.       kind: null,
  1001.       width: stream.width || null,
  1002.       height: stream.height || null,
  1003.       frameRate: null,
  1004.       pixelAspectRatio: null,
  1005.       hdr: null,
  1006.       mimeType: stream.mimeType,
  1007.       codecs: null,
  1008.       audioCodec: null,
  1009.       videoCodec: null,
  1010.       primary: false,
  1011.       roles: [],
  1012.       audioRoles: null,
  1013.       forced: false,
  1014.       videoId: null,
  1015.       audioId: null,
  1016.       channelsCount: null,
  1017.       audioSamplingRate: null,
  1018.       spatialAudio: false,
  1019.       tilesLayout: stream.tilesLayout || null,
  1020.       audioBandwidth: null,
  1021.       videoBandwidth: null,
  1022.       originalVideoId: null,
  1023.       originalAudioId: null,
  1024.       originalTextId: null,
  1025.       originalImageId: stream.originalId,
  1026.     };
  1028.     return track;
  1029.   }
  1032.   /**
  1033.    * Generate and return an ID for this track, since the ID field is optional.
  1034.    *
  1035.    * @param {TextTrack|AudioTrack} html5Track
  1036.    * @return {number} The generated ID.
  1037.    */
  1038.   static html5TrackId(html5Track) {
  1039.     if (!html5Track['__shaka_id']) {
  1040.       html5Track['__shaka_id'] = shaka.util.StreamUtils.nextTrackId_++;
  1041.     }
  1042.     return html5Track['__shaka_id'];
  1043.   }
  1046.   /**
  1047.    * @param {TextTrack} textTrack
  1048.    * @return {shaka.extern.Track}
  1049.    */
  1050.   static html5TextTrackToTrack(textTrack) {
  1051.     const CLOSED_CAPTION_MIMETYPE =
  1052.         shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE;
  1053.     const StreamUtils = shaka.util.StreamUtils;
  1055.     /** @type {shaka.extern.Track} */
  1056.     const track = StreamUtils.html5TrackToGenericShakaTrack_(textTrack);
  1057.     track.active = textTrack.mode != 'disabled';
  1058.     track.type = 'text';
  1059.     track.originalTextId = textTrack.id;
  1060.     if (textTrack.kind == 'captions') {
  1061.       track.mimeType = CLOSED_CAPTION_MIMETYPE;
  1062.     }
  1063.     if (textTrack.kind) {
  1064.       track.roles = [textTrack.kind];
  1065.     }
  1066.     if (textTrack.kind == 'forced') {
  1067.       track.forced = true;
  1068.     }
  1070.     return track;
  1071.   }
  1074.   /**
  1075.    * @param {AudioTrack} audioTrack
  1076.    * @return {shaka.extern.Track}
  1077.    */
  1078.   static html5AudioTrackToTrack(audioTrack) {
  1079.     const StreamUtils = shaka.util.StreamUtils;
  1081.     /** @type {shaka.extern.Track} */
  1082.     const track = StreamUtils.html5TrackToGenericShakaTrack_(audioTrack);
  1083.     track.active = audioTrack.enabled;
  1084.     track.type = 'variant';
  1085.     track.originalAudioId = audioTrack.id;
  1087.     if (audioTrack.kind == 'main') {
  1088.       track.primary = true;
  1089.     }
  1090.     if (audioTrack.kind) {
  1091.       track.roles = [audioTrack.kind];
  1092.       track.audioRoles = [audioTrack.kind];
  1093.       track.label = audioTrack.label;
  1094.     }
  1096.     return track;
  1097.   }
  1100.   /**
  1101.    * Creates a Track object with non-type specific fields filled out.  The
  1102.    * caller is responsible for completing the Track object with any
  1103.    * type-specific information (audio or text).
  1104.    *
  1105.    * @param {TextTrack|AudioTrack} html5Track
  1106.    * @return {shaka.extern.Track}
  1107.    * @private
  1108.    */
  1109.   static html5TrackToGenericShakaTrack_(html5Track) {
  1110.     /** @type {shaka.extern.Track} */
  1111.     const track = {
  1112.       id: shaka.util.StreamUtils.html5TrackId(html5Track),
  1113.       active: false,
  1114.       type: '',
  1115.       bandwidth: 0,
  1116.       language: shaka.util.LanguageUtils.normalize(html5Track.language),
  1117.       label: html5Track.label,
  1118.       kind: html5Track.kind,
  1119.       width: null,
  1120.       height: null,
  1121.       frameRate: null,
  1122.       pixelAspectRatio: null,
  1123.       hdr: null,
  1124.       mimeType: null,
  1125.       codecs: null,
  1126.       audioCodec: null,
  1127.       videoCodec: null,
  1128.       primary: false,
  1129.       roles: [],
  1130.       forced: false,
  1131.       audioRoles: null,
  1132.       videoId: null,
  1133.       audioId: null,
  1134.       channelsCount: null,
  1135.       audioSamplingRate: null,
  1136.       spatialAudio: false,
  1137.       tilesLayout: null,
  1138.       audioBandwidth: null,
  1139.       videoBandwidth: null,
  1140.       originalVideoId: null,
  1141.       originalAudioId: null,
  1142.       originalTextId: null,
  1143.       originalImageId: null,
  1144.     };
  1146.     return track;
  1147.   }
  1150.   /**
  1151.    * Determines if the given variant is playable.
  1152.    * @param {!shaka.extern.Variant} variant
  1153.    * @return {boolean}
  1154.    */
  1155.   static isPlayable(variant) {
  1156.     return variant.allowedByApplication && variant.allowedByKeySystem;
  1157.   }
  1160.   /**
  1161.    * Filters out unplayable variants.
  1162.    * @param {!Array.<!shaka.extern.Variant>} variants
  1163.    * @return {!Array.<!shaka.extern.Variant>}
  1164.    */
  1165.   static getPlayableVariants(variants) {
  1166.     return variants.filter((variant) => {
  1167.       return shaka.util.StreamUtils.isPlayable(variant);
  1168.     });
  1169.   }
  1172.   /**
  1173.    * Filters variants according to the given audio channel count config.
  1174.    *
  1175.    * @param {!Array.<shaka.extern.Variant>} variants
  1176.    * @param {number} preferredAudioChannelCount
  1177.    * @return {!Array.<!shaka.extern.Variant>}
  1178.    */
  1179.   static filterVariantsByAudioChannelCount(
  1180.       variants, preferredAudioChannelCount) {
  1181.     // Group variants by their audio channel counts.
  1182.     const variantsWithChannelCounts =
  1183.         variants.filter((v) => v.audio && v.audio.channelsCount);
  1185.     /** @type {!Map.<number, !Array.<shaka.extern.Variant>>} */
  1186.     const variantsByChannelCount = new Map();
  1187.     for (const variant of variantsWithChannelCounts) {
  1188.       const count = variant.audio.channelsCount;
  1189.       goog.asserts.assert(count != null, 'Must have count after filtering!');
  1190.       if (!variantsByChannelCount.has(count)) {
  1191.         variantsByChannelCount.set(count, []);
  1192.       }
  1193.       variantsByChannelCount.get(count).push(variant);
  1194.     }
  1196.     /** @type {!Array.<number>} */
  1197.     const channelCounts = Array.from(variantsByChannelCount.keys());
  1199.     // If no variant has audio channel count info, return the original variants.
  1200.     if (channelCounts.length == 0) {
  1201.       return variants;
  1202.     }
  1204.     // Choose the variants with the largest number of audio channels less than
  1205.     // or equal to the configured number of audio channels.
  1206.     const countLessThanOrEqualtoConfig =
  1207.         channelCounts.filter((count) => count <= preferredAudioChannelCount);
  1208.     if (countLessThanOrEqualtoConfig.length) {
  1209.       return variantsByChannelCount.get(
  1210.           Math.max(...countLessThanOrEqualtoConfig));
  1211.     }
  1213.     // If all variants have more audio channels than the config, choose the
  1214.     // variants with the fewest audio channels.
  1215.     return variantsByChannelCount.get(Math.min(...channelCounts));
  1216.   }
  1218.   /**
  1219.    * Chooses streams according to the given config.
  1220.    *
  1221.    * @param {!Array.<shaka.extern.Stream>} streams
  1222.    * @param {string} preferredLanguage
  1223.    * @param {string} preferredRole
  1224.    * @param {boolean} preferredForced
  1225.    * @return {!Array.<!shaka.extern.Stream>}
  1226.    */
  1227.   static filterStreamsByLanguageAndRole(
  1228.       streams, preferredLanguage, preferredRole, preferredForced) {
  1229.     const LanguageUtils = shaka.util.LanguageUtils;
  1231.     /** @type {!Array.<!shaka.extern.Stream>} */
  1232.     let chosen = streams;
  1234.     // Start with the set of primary streams.
  1235.     /** @type {!Array.<!shaka.extern.Stream>} */
  1236.     const primary = streams.filter((stream) => {
  1237.       return stream.primary;
  1238.     });
  1240.     if (primary.length) {
  1241.       chosen = primary;
  1242.     }
  1244.     // Now reduce the set to one language.  This covers both arbitrary language
  1245.     // choice and the reduction of the "primary" stream set to one language.
  1246.     const firstLanguage = chosen.length ? chosen[0].language : '';
  1247.     chosen = chosen.filter((stream) => {
  1248.       return stream.language == firstLanguage;
  1249.     });
  1251.     // Find the streams that best match our language preference. This will
  1252.     // override previous selections.
  1253.     if (preferredLanguage) {
  1254.       const closestLocale = LanguageUtils.findClosestLocale(
  1255.           LanguageUtils.normalize(preferredLanguage),
  1256.           streams.map((stream) => stream.language));
  1258.       // Only replace |chosen| if we found a locale that is close to our
  1259.       // preference.
  1260.       if (closestLocale) {
  1261.         chosen = streams.filter((stream) => {
  1262.           const locale = LanguageUtils.normalize(stream.language);
  1263.           return locale == closestLocale;
  1264.         });
  1265.       }
  1266.     }
  1268.     // Filter by forced preference
  1269.     chosen = chosen.filter((stream) => {
  1270.       return stream.forced == preferredForced;
  1271.     });
  1273.     // Now refine the choice based on role preference.
  1274.     if (preferredRole) {
  1275.       const roleMatches = shaka.util.StreamUtils.filterTextStreamsByRole_(
  1276.           chosen, preferredRole);
  1277.       if (roleMatches.length) {
  1278.         return roleMatches;
  1279.       } else {
  1280.         shaka.log.warning('No exact match for the text role could be found.');
  1281.       }
  1282.     } else {
  1283.       // Prefer text streams with no roles, if they exist.
  1284.       const noRoleMatches = chosen.filter((stream) => {
  1285.         return stream.roles.length == 0;
  1286.       });
  1287.       if (noRoleMatches.length) {
  1288.         return noRoleMatches;
  1289.       }
  1290.     }
  1292.     // Either there was no role preference, or it could not be satisfied.
  1293.     // Choose an arbitrary role, if there are any, and filter out any other
  1294.     // roles. This ensures we never adapt between roles.
  1296.     const allRoles = chosen.map((stream) => {
  1297.       return stream.roles;
  1298.     }).reduce(shaka.util.Functional.collapseArrays, []);
  1300.     if (!allRoles.length) {
  1301.       return chosen;
  1302.     }
  1303.     return shaka.util.StreamUtils.filterTextStreamsByRole_(chosen, allRoles[0]);
  1304.   }
  1307.   /**
  1308.    * Filter text Streams by role.
  1309.    *
  1310.    * @param {!Array.<shaka.extern.Stream>} textStreams
  1311.    * @param {string} preferredRole
  1312.    * @return {!Array.<shaka.extern.Stream>}
  1313.    * @private
  1314.    */
  1315.   static filterTextStreamsByRole_(textStreams, preferredRole) {
  1316.     return textStreams.filter((stream) => {
  1317.       return stream.roles.includes(preferredRole);
  1318.     });
  1319.   }
  1322.   /**
  1323.    * Checks if the given stream is an audio stream.
  1324.    *
  1325.    * @param {shaka.extern.Stream} stream
  1326.    * @return {boolean}
  1327.    */
  1328.   static isAudio(stream) {
  1329.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1330.     return stream.type == ContentType.AUDIO;
  1331.   }
  1334.   /**
  1335.    * Checks if the given stream is a video stream.
  1336.    *
  1337.    * @param {shaka.extern.Stream} stream
  1338.    * @return {boolean}
  1339.    */
  1340.   static isVideo(stream) {
  1341.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1342.     return stream.type == ContentType.VIDEO;
  1343.   }
  1346.   /**
  1347.    * Get all non-null streams in the variant as an array.
  1348.    *
  1349.    * @param {shaka.extern.Variant} variant
  1350.    * @return {!Array.<shaka.extern.Stream>}
  1351.    */
  1352.   static getVariantStreams(variant) {
  1353.     const streams = [];
  1355.     if (variant.audio) {
  1356.       streams.push(variant.audio);
  1357.     }
  1358.     if (variant.video) {
  1359.       streams.push(variant.video);
  1360.     }
  1362.     return streams;
  1363.   }
  1366.   /**
  1367.    * Returns a string of a variant, with the attribute values of its audio
  1368.    * and/or video streams for log printing.
  1369.    * @param {shaka.extern.Variant} variant
  1370.    * @return {string}
  1371.    * @private
  1372.    */
  1373.   static getVariantSummaryString_(variant) {
  1374.     const summaries = [];
  1375.     if (variant.audio) {
  1376.       summaries.push(shaka.util.StreamUtils.getStreamSummaryString_(
  1377.           variant.audio));
  1378.     }
  1379.     if (variant.video) {
  1380.       summaries.push(shaka.util.StreamUtils.getStreamSummaryString_(
  1381.           variant.video));
  1382.     }
  1383.     return summaries.join(', ');
  1384.   }
  1386.   /**
  1387.    * Returns a string of an audio or video stream for log printing.
  1388.    * @param {shaka.extern.Stream} stream
  1389.    * @return {string}
  1390.    * @private
  1391.    */
  1392.   static getStreamSummaryString_(stream) {
  1393.     // Accepted parameters for Chromecast can be found (internally) at
  1394.     // go/cast-mime-params
  1396.     if (shaka.util.StreamUtils.isAudio(stream)) {
  1397.       return 'type=audio' +
  1398.              ' codecs=' + stream.codecs +
  1399.              ' bandwidth='+ stream.bandwidth +
  1400.              ' channelsCount=' + stream.channelsCount +
  1401.              ' audioSamplingRate=' + stream.audioSamplingRate;
  1402.     }
  1404.     if (shaka.util.StreamUtils.isVideo(stream)) {
  1405.       return 'type=video' +
  1406.              ' codecs=' + stream.codecs +
  1407.              ' bandwidth=' + stream.bandwidth +
  1408.              ' frameRate=' + stream.frameRate +
  1409.              ' width=' + stream.width +
  1410.              ' height=' + stream.height;
  1411.     }
  1413.     return 'unexpected stream type';
  1414.   }
  1415. };
  1418. /** @private {number} */
  1419. shaka.util.StreamUtils.nextTrackId_ = 0;
  1421. /**
  1422.  * @enum {string}
  1423.  */
  1424. shaka.util.StreamUtils.DecodingAttributes = {
  1425.   SMOOTH: 'smooth',
  1426.   POWER: 'powerEfficient',
  1427.   BANDWIDTH: 'bandwidth',
  1428. };