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.media.Capabilities');
  12. goog.require('shaka.text.TextEngine');
  13. goog.require('shaka.util.Functional');
  14. goog.require('shaka.util.LanguageUtils');
  15. goog.require('shaka.util.ManifestParserUtils');
  16. goog.require('shaka.util.MimeUtils');
  17. goog.require('shaka.util.MultiMap');
  18. goog.require('shaka.util.ObjectUtils');
  19. goog.require('shaka.util.Platform');
  20. goog.requireType('shaka.media.DrmEngine');
  23. /**
  24.  * @summary A set of utility functions for dealing with Streams and Manifests.
  25.  * @export
  26.  */
  27. shaka.util.StreamUtils = class {
  28.   /**
  29.    * In case of multiple usable codecs, choose one based on lowest average
  30.    * bandwidth and filter out the rest.
  31.    * Also filters out variants that have too many audio channels.
  32.    * @param {!shaka.extern.Manifest} manifest
  33.    * @param {!Array.<string>} preferredVideoCodecs
  34.    * @param {!Array.<string>} preferredAudioCodecs
  35.    * @param {!Array.<string>} preferredDecodingAttributes
  36.    */
  37.   static chooseCodecsAndFilterManifest(manifest, preferredVideoCodecs,
  38.       preferredAudioCodecs, preferredDecodingAttributes) {
  39.     const StreamUtils = shaka.util.StreamUtils;
  40.     const MimeUtils = shaka.util.MimeUtils;
  42.     let variants = manifest.variants;
  43.     // To start, choose the codecs based on configured preferences if available.
  44.     if (preferredVideoCodecs.length || preferredAudioCodecs.length) {
  45.       variants = StreamUtils.choosePreferredCodecs(variants,
  46.           preferredVideoCodecs, preferredAudioCodecs);
  47.     }
  49.     if (preferredDecodingAttributes.length) {
  50.       // group variants by resolution and choose preferred variants only
  51.       /** @type {!shaka.util.MultiMap.<shaka.extern.Variant>} */
  52.       const variantsByResolutionMap = new shaka.util.MultiMap();
  53.       for (const variant of variants) {
  54.         variantsByResolutionMap
  55.             .push(String(variant.video.width || 0), variant);
  56.       }
  57.       const bestVariants = [];
  58.       variantsByResolutionMap.forEach((width, variantsByResolution) => {
  59.         let highestMatch = 0;
  60.         let matchingVariants = [];
  61.         for (const variant of variantsByResolution) {
  62.           const matchCount = preferredDecodingAttributes.filter(
  63.               (attribute) => variant.decodingInfos[0][attribute],
  64.           ).length;
  65.           if (matchCount > highestMatch) {
  66.             highestMatch = matchCount;
  67.             matchingVariants = [variant];
  68.           } else if (matchCount == highestMatch) {
  69.             matchingVariants.push(variant);
  70.           }
  71.         }
  72.         bestVariants.push(...matchingVariants);
  73.       });
  74.       variants = bestVariants;
  75.     }
  77.     const audioStreamsSet = new Set();
  78.     const videoStreamsSet = new Set();
  79.     for (const variant of variants) {
  80.       if (variant.audio) {
  81.         audioStreamsSet.add(variant.audio);
  82.       }
  83.       if (variant.video) {
  84.         videoStreamsSet.add(variant.video);
  85.       }
  86.     }
  88.     const audioStreams = Array.from(audioStreamsSet).sort((v1, v2) => {
  89.       return v1.bandwidth - v2.bandwidth;
  90.     });
  91.     const validAudioIds = [];
  92.     const validAudioStreamsMap = new Map();
  93.     const getAudioId = (stream) => {
  94.       return stream.language + (stream.channelsCount || 0) +
  95.         (stream.audioSamplingRate || 0) + stream.roles.join(',') +
  96.         stream.label + stream.groupId + stream.fastSwitching;
  97.     };
  98.     for (const stream of audioStreams) {
  99.       const groupId = getAudioId(stream);
  100.       const validAudioStreams = validAudioStreamsMap.get(groupId) || [];
  101.       if (!validAudioStreams.length) {
  102.         validAudioStreams.push(stream);
  103.         validAudioIds.push(stream.id);
  104.       } else {
  105.         const previousStream = validAudioStreams[validAudioStreams.length - 1];
  106.         const previousCodec =
  107.           MimeUtils.getNormalizedCodec(previousStream.codecs);
  108.         const currentCodec =
  109.           MimeUtils.getNormalizedCodec(stream.codecs);
  110.         if (previousCodec == currentCodec) {
  111.           if (!stream.bandwidth || !previousStream.bandwidth ||
  112.               stream.bandwidth > previousStream.bandwidth) {
  113.             validAudioStreams.push(stream);
  114.             validAudioIds.push(stream.id);
  115.           }
  116.         }
  117.       }
  118.       validAudioStreamsMap.set(groupId, validAudioStreams);
  119.     }
  121.     const videoStreams = Array.from(videoStreamsSet)
  122.         .sort((v1, v2) => {
  123.           if (!v1.bandwidth || !v2.bandwidth) {
  124.             return v1.width - v2.width;
  125.           }
  126.           return v1.bandwidth - v2.bandwidth;
  127.         });
  129.     const isChangeTypeSupported =
  130.       shaka.media.Capabilities.isChangeTypeSupported();
  132.     const validVideoIds = [];
  133.     const validVideoStreamsMap = new Map();
  134.     const getVideoGroupId = (stream) => {
  135.       return Math.round(stream.frameRate || 0) + (stream.hdr || '') +
  136.           stream.fastSwitching;
  137.     };
  138.     for (const stream of videoStreams) {
  139.       const groupId = getVideoGroupId(stream);
  140.       const validVideoStreams = validVideoStreamsMap.get(groupId) || [];
  141.       if (!validVideoStreams.length) {
  142.         validVideoStreams.push(stream);
  143.         validVideoIds.push(stream.id);
  144.       } else {
  145.         const previousStream = validVideoStreams[validVideoStreams.length - 1];
  146.         if (!isChangeTypeSupported) {
  147.           const previousCodec =
  148.             MimeUtils.getNormalizedCodec(previousStream.codecs);
  149.           const currentCodec =
  150.             MimeUtils.getNormalizedCodec(stream.codecs);
  151.           if (previousCodec !== currentCodec) {
  152.             continue;
  153.           }
  154.         }
  155.         if (stream.width > previousStream.width ||
  156.           stream.height > previousStream.height) {
  157.           validVideoStreams.push(stream);
  158.           validVideoIds.push(stream.id);
  159.         } else if (stream.width == previousStream.width &&
  160.           stream.height == previousStream.height) {
  161.           const previousCodec =
  162.             MimeUtils.getNormalizedCodec(previousStream.codecs);
  163.           const currentCodec =
  164.             MimeUtils.getNormalizedCodec(stream.codecs);
  165.           if (previousCodec == currentCodec) {
  166.             if (!stream.bandwidth || !previousStream.bandwidth ||
  167.                 stream.bandwidth > previousStream.bandwidth) {
  168.               validVideoStreams.push(stream);
  169.               validVideoIds.push(stream.id);
  170.             }
  171.           }
  172.         }
  173.       }
  174.       validVideoStreamsMap.set(groupId, validVideoStreams);
  175.     }
  177.     // Filter out any variants that don't match, forcing AbrManager to choose
  178.     // from a single video codec and a single audio codec possible.
  179.     manifest.variants = manifest.variants.filter((variant) => {
  180.       const audio = variant.audio;
  181.       const video = variant.video;
  182.       if (audio) {
  183.         if (!validAudioIds.includes(audio.id)) {
  184.           shaka.log.debug('Dropping Variant (better codec available)', variant);
  185.           return false;
  186.         }
  187.       }
  188.       if (video) {
  189.         if (!validVideoIds.includes(video.id)) {
  190.           shaka.log.debug('Dropping Variant (better codec available)', variant);
  191.           return false;
  192.         }
  193.       }
  194.       return true;
  195.     });
  196.   }
  198.   /**
  199.    * Choose the codecs by configured preferred audio and video codecs.
  200.    *
  201.    * @param {!Array<shaka.extern.Variant>} variants
  202.    * @param {!Array.<string>} preferredVideoCodecs
  203.    * @param {!Array.<string>} preferredAudioCodecs
  204.    * @return {!Array<shaka.extern.Variant>}
  205.    */
  206.   static choosePreferredCodecs(variants, preferredVideoCodecs,
  207.       preferredAudioCodecs) {
  208.     let subset = variants;
  209.     for (const videoCodec of preferredVideoCodecs) {
  210.       const filtered = subset.filter((variant) => {
  211.         return variant.video && variant.video.codecs.startsWith(videoCodec);
  212.       });
  213.       if (filtered.length) {
  214.         subset = filtered;
  215.         break;
  216.       }
  217.     }
  219.     for (const audioCodec of preferredAudioCodecs) {
  220.       const filtered = subset.filter((variant) => {
  221.         return variant.audio && variant.audio.codecs.startsWith(audioCodec);
  222.       });
  223.       if (filtered.length) {
  224.         subset = filtered;
  225.         break;
  226.       }
  227.     }
  228.     return subset;
  229.   }
  231.   /**
  232.    * Filter the variants in |manifest| to only include the variants that meet
  233.    * the given restrictions.
  234.    *
  235.    * @param {!shaka.extern.Manifest} manifest
  236.    * @param {shaka.extern.Restrictions} restrictions
  237.    * @param {shaka.extern.Resolution} maxHwResolution
  238.    */
  239.   static filterByRestrictions(manifest, restrictions, maxHwResolution) {
  240.     manifest.variants = manifest.variants.filter((variant) => {
  241.       return shaka.util.StreamUtils.meetsRestrictions(
  242.           variant, restrictions, maxHwResolution);
  243.     });
  244.   }
  246.   /**
  247.    * @param {shaka.extern.Variant} variant
  248.    * @param {shaka.extern.Restrictions} restrictions
  249.    *   Configured restrictions from the user.
  250.    * @param {shaka.extern.Resolution} maxHwRes
  251.    *   The maximum resolution the hardware can handle.
  252.    *   This is applied separately from user restrictions because the setting
  253.    *   should not be easily replaced by the user's configuration.
  254.    * @return {boolean}
  255.    * @export
  256.    */
  257.   static meetsRestrictions(variant, restrictions, maxHwRes) {
  258.     /** @type {function(number, number, number):boolean} */
  259.     const inRange = (x, min, max) => {
  260.       return x >= min && x <= max;
  261.     };
  263.     const video = variant.video;
  265.     // |video.width| and |video.height| can be undefined, which breaks
  266.     // the math, so make sure they are there first.
  267.     if (video && video.width && video.height) {
  268.       let videoWidth = video.width;
  269.       let videoHeight = video.height;
  270.       if (videoHeight > videoWidth) {
  271.         // Vertical video.
  272.         [videoWidth, videoHeight] = [videoHeight, videoWidth];
  273.       }
  275.       if (!inRange(videoWidth,
  276.           restrictions.minWidth,
  277.           Math.min(restrictions.maxWidth, maxHwRes.width))) {
  278.         return false;
  279.       }
  281.       if (!inRange(videoHeight,
  282.           restrictions.minHeight,
  283.           Math.min(restrictions.maxHeight, maxHwRes.height))) {
  284.         return false;
  285.       }
  287.       if (!inRange(video.width * video.height,
  288.           restrictions.minPixels,
  289.           restrictions.maxPixels)) {
  290.         return false;
  291.       }
  292.     }
  294.     // |variant.video.frameRate| can be undefined, which breaks
  295.     // the math, so make sure they are there first.
  296.     if (variant && variant.video && variant.video.frameRate) {
  297.       if (!inRange(variant.video.frameRate,
  298.           restrictions.minFrameRate,
  299.           restrictions.maxFrameRate)) {
  300.         return false;
  301.       }
  302.     }
  304.     // |variant.audio.channelsCount| can be undefined, which breaks
  305.     // the math, so make sure they are there first.
  306.     if (variant && variant.audio && variant.audio.channelsCount) {
  307.       if (!inRange(variant.audio.channelsCount,
  308.           restrictions.minChannelsCount,
  309.           restrictions.maxChannelsCount)) {
  310.         return false;
  311.       }
  312.     }
  314.     if (!inRange(variant.bandwidth,
  315.         restrictions.minBandwidth,
  316.         restrictions.maxBandwidth)) {
  317.       return false;
  318.     }
  320.     return true;
  321.   }
  324.   /**
  325.    * @param {!Array.<shaka.extern.Variant>} variants
  326.    * @param {shaka.extern.Restrictions} restrictions
  327.    * @param {shaka.extern.Resolution} maxHwRes
  328.    * @return {boolean} Whether the tracks changed.
  329.    */
  330.   static applyRestrictions(variants, restrictions, maxHwRes) {
  331.     let tracksChanged = false;
  333.     for (const variant of variants) {
  334.       const originalAllowed = variant.allowedByApplication;
  335.       variant.allowedByApplication = shaka.util.StreamUtils.meetsRestrictions(
  336.           variant, restrictions, maxHwRes);
  338.       if (originalAllowed != variant.allowedByApplication) {
  339.         tracksChanged = true;
  340.       }
  341.     }
  343.     return tracksChanged;
  344.   }
  347.   /**
  348.    * Alters the given Manifest to filter out any unplayable streams.
  349.    *
  350.    * @param {shaka.media.DrmEngine} drmEngine
  351.    * @param {shaka.extern.Manifest} manifest
  352.    * @param {!Array<string>=} preferredKeySystems
  353.    */
  354.   static async filterManifest(drmEngine, manifest, preferredKeySystems = []) {
  355.     await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
  356.         drmEngine, manifest, manifest.offlineSessionIds.length > 0,
  357.         preferredKeySystems);
  358.     shaka.util.StreamUtils.filterTextStreams_(manifest);
  359.     await shaka.util.StreamUtils.filterImageStreams_(manifest);
  360.   }
  363.   /**
  364.    * Alters the given Manifest to filter out any streams unsupported by the
  365.    * platform via MediaCapabilities.decodingInfo() API.
  366.    *
  367.    * @param {shaka.media.DrmEngine} drmEngine
  368.    * @param {shaka.extern.Manifest} manifest
  369.    * @param {boolean} usePersistentLicenses
  370.    * @param {!Array<string>} preferredKeySystems
  371.    */
  372.   static async filterManifestByMediaCapabilities(
  373.       drmEngine, manifest, usePersistentLicenses, preferredKeySystems) {
  374.     goog.asserts.assert(navigator.mediaCapabilities,
  375.         'MediaCapabilities should be valid.');
  377.     await shaka.util.StreamUtils.getDecodingInfosForVariants(
  378.         manifest.variants, usePersistentLicenses, /* srcEquals= */ false,
  379.         preferredKeySystems);
  381.     let keySystem = null;
  382.     if (drmEngine) {
  383.       const drmInfo = drmEngine.getDrmInfo();
  384.       if (drmInfo) {
  385.         keySystem = drmInfo.keySystem;
  386.       }
  387.     }
  389.     const StreamUtils = shaka.util.StreamUtils;
  391.     manifest.variants = manifest.variants.filter((variant) => {
  392.       const supported = StreamUtils.checkVariantSupported_(variant, keySystem);
  393.       // Filter out all unsupported variants.
  394.       if (!supported) {
  395.         shaka.log.debug('Dropping variant - not compatible with platform',
  396.             StreamUtils.getVariantSummaryString_(variant));
  397.       }
  398.       return supported;
  399.     });
  400.   }
  403.   /**
  404.    * @param {!shaka.extern.Variant} variant
  405.    * @param {?string} keySystem
  406.    * @return {boolean}
  407.    * @private
  408.    */
  409.   static checkVariantSupported_(variant, keySystem) {
  410.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  411.     const Capabilities = shaka.media.Capabilities;
  412.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  413.     const MimeUtils = shaka.util.MimeUtils;
  414.     const StreamUtils = shaka.util.StreamUtils;
  416.     const isXboxOne = shaka.util.Platform.isXboxOne();
  417.     const isFirefoxAndroid = shaka.util.Platform.isFirefox() &&
  418.         shaka.util.Platform.isAndroid();
  420.     // See: https://github.com/shaka-project/shaka-player/issues/3860
  421.     const video = variant.video;
  422.     const videoWidth = (video && video.width) || 0;
  423.     const videoHeight = (video && video.height) || 0;
  425.     // See: https://github.com/shaka-project/shaka-player/issues/3380
  426.     // Note: it makes sense to drop early
  427.     if (isXboxOne && video && (videoWidth > 1920 || videoHeight > 1080) &&
  428.         (video.codecs.includes('avc1.') || video.codecs.includes('avc3.'))) {
  429.       return false;
  430.     }
  432.     if (video) {
  433.       let videoCodecs = StreamUtils.getCorrectVideoCodecs(video.codecs);
  434.       // For multiplexed streams. Here we must check the audio of the
  435.       // stream to see if it is compatible.
  436.       if (video.codecs.includes(',')) {
  437.         const allCodecs = video.codecs.split(',');
  439.         videoCodecs = ManifestParserUtils.guessCodecs(
  440.             ContentType.VIDEO, allCodecs);
  441.         videoCodecs = StreamUtils.getCorrectVideoCodecs(videoCodecs);
  442.         let audioCodecs = ManifestParserUtils.guessCodecs(
  443.             ContentType.AUDIO, allCodecs);
  444.         audioCodecs = StreamUtils.getCorrectAudioCodecs(
  445.             audioCodecs, video.mimeType);
  447.         const audioFullType = MimeUtils.getFullOrConvertedType(
  448.             video.mimeType, audioCodecs, ContentType.AUDIO);
  450.         if (!Capabilities.isTypeSupported(audioFullType)) {
  451.           return false;
  452.         }
  454.         // Update the codec string with the (possibly) converted codecs.
  455.         videoCodecs = [videoCodecs, audioCodecs].join(',');
  456.       }
  458.       const fullType = MimeUtils.getFullOrConvertedType(
  459.           video.mimeType, videoCodecs, ContentType.VIDEO);
  461.       if (!Capabilities.isTypeSupported(fullType)) {
  462.         return false;
  463.       }
  465.       // Update the codec string with the (possibly) converted codecs.
  466.       video.codecs = videoCodecs;
  467.     }
  469.     const audio = variant.audio;
  471.     // See: https://github.com/shaka-project/shaka-player/issues/6111
  472.     // It seems that Firefox Android reports that it supports
  473.     // Opus + Widevine, but it is not actually supported.
  474.     // It makes sense to drop early.
  475.     if (isFirefoxAndroid && audio && audio.encrypted &&
  476.         audio.codecs.toLowerCase().includes('opus')) {
  477.       return false;
  478.     }
  480.     if (audio) {
  481.       const codecs = StreamUtils.getCorrectAudioCodecs(
  482.           audio.codecs, audio.mimeType);
  483.       const fullType = MimeUtils.getFullOrConvertedType(
  484.           audio.mimeType, codecs, ContentType.AUDIO);
  486.       if (!Capabilities.isTypeSupported(fullType)) {
  487.         return false;
  488.       }
  490.       // Update the codec string with the (possibly) converted codecs.
  491.       audio.codecs = codecs;
  492.     }
  494.     return variant.decodingInfos.some((decodingInfo) => {
  495.       if (!decodingInfo.supported) {
  496.         return false;
  497.       }
  498.       if (keySystem) {
  499.         const keySystemAccess = decodingInfo.keySystemAccess;
  500.         if (keySystemAccess) {
  501.           if (keySystemAccess.keySystem != keySystem) {
  502.             return false;
  503.           }
  504.         }
  505.       }
  506.       return true;
  507.     });
  508.   }
  511.   /**
  512.    * Constructs a string out of an object, similar to the JSON.stringify method.
  513.    * Unlike that method, this guarantees that the order of the keys is
  514.    * alphabetical, so it can be used as a way to reliably compare two objects.
  515.    *
  516.    * @param {!Object} obj
  517.    * @return {string}
  518.    * @private
  519.    */
  520.   static alphabeticalKeyOrderStringify_(obj) {
  521.     const keys = [];
  522.     for (const key in obj) {
  523.       keys.push(key);
  524.     }
  525.     // Alphabetically sort the keys, so they will be in a reliable order.
  526.     keys.sort();
  528.     const terms = [];
  529.     for (const key of keys) {
  530.       const escapedKey = JSON.stringify(key);
  531.       const value = obj[key];
  532.       if (value instanceof Object) {
  533.         const stringifiedValue =
  534.             shaka.util.StreamUtils.alphabeticalKeyOrderStringify_(value);
  535.         terms.push(escapedKey + ':' + stringifiedValue);
  536.       } else {
  537.         const escapedValue = JSON.stringify(value);
  538.         terms.push(escapedKey + ':' + escapedValue);
  539.       }
  540.     }
  541.     return '{' + terms.join(',') + '}';
  542.   }
  545.   /**
  546.    * Queries mediaCapabilities for the decoding info for that decoding config,
  547.    * and assigns it to the given variant.
  548.    * If that query has been done before, instead return a cached result.
  549.    * @param {!shaka.extern.Variant} variant
  550.    * @param {!Array.<!MediaDecodingConfiguration>} decodingConfigs
  551.    * @private
  552.    */
  553.   static async getDecodingInfosForVariant_(variant, decodingConfigs) {
  554.     /**
  555.      * @param {?MediaCapabilitiesDecodingInfo} a
  556.      * @param {!MediaCapabilitiesDecodingInfo} b
  557.      * @return {!MediaCapabilitiesDecodingInfo}
  558.      */
  559.     const merge = (a, b) => {
  560.       if (!a) {
  561.         return b;
  562.       } else {
  563.         const res = shaka.util.ObjectUtils.shallowCloneObject(a);
  564.         res.supported = a.supported && b.supported;
  565.         res.powerEfficient = a.powerEfficient && b.powerEfficient;
  566.         res.smooth = a.smooth && b.smooth;
  567.         if (b.keySystemAccess && !res.keySystemAccess) {
  568.           res.keySystemAccess = b.keySystemAccess;
  569.         }
  570.         return res;
  571.       }
  572.     };
  574.     const StreamUtils = shaka.util.StreamUtils;
  575.     /** @type {?MediaCapabilitiesDecodingInfo} */
  576.     let finalResult = null;
  577.     const promises = [];
  578.     for (const decodingConfig of decodingConfigs) {
  579.       const cacheKey =
  580.           StreamUtils.alphabeticalKeyOrderStringify_(decodingConfig);
  582.       const cache = StreamUtils.decodingConfigCache_;
  583.       if (cache[cacheKey]) {
  584.         shaka.log.v2('Using cached results of mediaCapabilities.decodingInfo',
  585.             'for key', cacheKey);
  586.         finalResult = merge(finalResult, cache[cacheKey]);
  587.       } else {
  588.         // Do a final pass-over of the decoding config: if a given stream has
  589.         // multiple codecs, that suggests that it switches between those codecs
  590.         // at points of the go-through.
  591.         // mediaCapabilities by itself will report "not supported" when you
  592.         // put in multiple different codecs, so each has to be checked
  593.         // individually. So check each and take the worst result, to determine
  594.         // overall variant compatibility.
  595.         promises.push(StreamUtils
  596.             .checkEachDecodingConfigCombination_(decodingConfig).then((res) => {
  597.               /** @type {?MediaCapabilitiesDecodingInfo} */
  598.               let acc = null;
  599.               for (const result of (res || [])) {
  600.                 acc = merge(acc, result);
  601.               }
  602.               if (acc) {
  603.                 cache[cacheKey] = acc;
  604.                 finalResult = merge(finalResult, acc);
  605.               }
  606.             }));
  607.       }
  608.     }
  609.     await Promise.all(promises);
  610.     if (finalResult) {
  611.       variant.decodingInfos.push(finalResult);
  612.     }
  613.   }
  615.   /**
  616.    * @param {!MediaDecodingConfiguration} decodingConfig
  617.    * @return {!Promise.<?Array.<!MediaCapabilitiesDecodingInfo>>}
  618.    * @private
  619.    */
  620.   static checkEachDecodingConfigCombination_(decodingConfig) {
  621.     let videoCodecs = [''];
  622.     if (decodingConfig.video) {
  623.       videoCodecs = shaka.util.MimeUtils.getCodecs(
  624.           decodingConfig.video.contentType).split(',');
  625.     }
  626.     let audioCodecs = [''];
  627.     if (decodingConfig.audio) {
  628.       audioCodecs = shaka.util.MimeUtils.getCodecs(
  629.           decodingConfig.audio.contentType).split(',');
  630.     }
  631.     const promises = [];
  632.     for (const videoCodec of videoCodecs) {
  633.       for (const audioCodec of audioCodecs) {
  634.         const copy = shaka.util.ObjectUtils.cloneObject(decodingConfig);
  635.         if (decodingConfig.video) {
  636.           const mimeType = shaka.util.MimeUtils.getBasicType(
  637.               copy.video.contentType);
  638.           copy.video.contentType = shaka.util.MimeUtils.getFullType(
  639.               mimeType, videoCodec);
  640.         }
  641.         if (decodingConfig.audio) {
  642.           const mimeType = shaka.util.MimeUtils.getBasicType(
  643.               copy.audio.contentType);
  644.           copy.audio.contentType = shaka.util.MimeUtils.getFullType(
  645.               mimeType, audioCodec);
  646.         }
  647.         promises.push(new Promise((resolve, reject) => {
  648.           navigator.mediaCapabilities.decodingInfo(copy).then((res) => {
  649.             resolve(res);
  650.           }).catch(reject);
  651.         }));
  652.       }
  653.     }
  654.     return Promise.all(promises).catch((e) => {
  655.       shaka.log.info('MediaCapabilities.decodingInfo() failed.',
  656.           JSON.stringify(decodingConfig), e);
  657.       return null;
  658.     });
  659.   }
  662.   /**
  663.    * Get the decodingInfo results of the variants via MediaCapabilities.
  664.    * This should be called after the DrmEngine is created and configured, and
  665.    * before DrmEngine sets the mediaKeys.
  666.    *
  667.    * @param {!Array.<shaka.extern.Variant>} variants
  668.    * @param {boolean} usePersistentLicenses
  669.    * @param {boolean} srcEquals
  670.    * @param {!Array<string>} preferredKeySystems
  671.    * @exportDoc
  672.    */
  673.   static async getDecodingInfosForVariants(variants, usePersistentLicenses,
  674.       srcEquals, preferredKeySystems) {
  675.     const gotDecodingInfo = variants.some((variant) =>
  676.       variant.decodingInfos.length);
  677.     if (gotDecodingInfo) {
  678.       shaka.log.debug('Already got the variants\' decodingInfo.');
  679.       return;
  680.     }
  682.     // Try to get preferred key systems first to avoid unneeded calls to CDM.
  683.     for (const preferredKeySystem of preferredKeySystems) {
  684.       let keySystemSatisfied = false;
  685.       for (const variant of variants) {
  686.         /** @type {!Array.<!Array.<!MediaDecodingConfiguration>>} */
  687.         const decodingConfigs = shaka.util.StreamUtils.getDecodingConfigs_(
  688.             variant, usePersistentLicenses, srcEquals)
  689.             .filter((configs) => {
  690.               // All configs in a batch will have the same keySystem.
  691.               const config = configs[0];
  692.               const keySystem = config.keySystemConfiguration &&
  693.                 config.keySystemConfiguration.keySystem;
  694.               return keySystem === preferredKeySystem;
  695.             });
  697.         // The reason we are performing this await in a loop rather than
  698.         // batching into a `promise.all` is performance related.
  699.         // https://github.com/shaka-project/shaka-player/pull/4708#discussion_r1022581178
  700.         for (const configs of decodingConfigs) {
  701.           // eslint-disable-next-line no-await-in-loop
  702.           await shaka.util.StreamUtils.getDecodingInfosForVariant_(
  703.               variant, configs);
  704.         }
  705.         if (variant.decodingInfos.length) {
  706.           keySystemSatisfied = true;
  707.         }
  708.       } // for (const variant of variants)
  709.       if (keySystemSatisfied) {
  710.         // Return if any preferred key system is already satisfied.
  711.         return;
  712.       }
  713.     } // for (const preferredKeySystem of preferredKeySystems)
  715.     for (const variant of variants) {
  716.       /** @type {!Array.<!Array.<!MediaDecodingConfiguration>>} */
  717.       const decodingConfigs = shaka.util.StreamUtils.getDecodingConfigs_(
  718.           variant, usePersistentLicenses, srcEquals)
  719.           .filter((configs) => {
  720.             // All configs in a batch will have the same keySystem.
  721.             const config = configs[0];
  722.             const keySystem = config.keySystemConfiguration &&
  723.               config.keySystemConfiguration.keySystem;
  724.             // Avoid checking preferred systems twice.
  725.             return !keySystem || !preferredKeySystems.includes(keySystem);
  726.           });
  728.       // The reason we are performing this await in a loop rather than
  729.       // batching into a `promise.all` is performance related.
  730.       // https://github.com/shaka-project/shaka-player/pull/4708#discussion_r1022581178
  731.       for (const configs of decodingConfigs) {
  732.         // eslint-disable-next-line no-await-in-loop
  733.         await shaka.util.StreamUtils.getDecodingInfosForVariant_(
  734.             variant, configs);
  735.       }
  736.     }
  737.   }
  740.   /**
  741.    * Generate a batch of MediaDecodingConfiguration objects to get the
  742.    * decodingInfo results for each variant.
  743.    * Each batch shares the same DRM information, and represents the various
  744.    * fullMimeType combinations of the streams.
  745.    * @param {!shaka.extern.Variant} variant
  746.    * @param {boolean} usePersistentLicenses
  747.    * @param {boolean} srcEquals
  748.    * @return {!Array.<!Array.<!MediaDecodingConfiguration>>}
  749.    * @private
  750.    */
  751.   static getDecodingConfigs_(variant, usePersistentLicenses, srcEquals) {
  752.     const audio = variant.audio;
  753.     const video = variant.video;
  755.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  756.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  757.     const MimeUtils = shaka.util.MimeUtils;
  758.     const StreamUtils = shaka.util.StreamUtils;
  760.     const videoConfigs = [];
  761.     const audioConfigs = [];
  762.     if (video) {
  763.       for (const fullMimeType of video.fullMimeTypes) {
  764.         let videoCodecs = MimeUtils.getCodecs(fullMimeType);
  766.         // For multiplexed streams with audio+video codecs, the config should
  767.         // have AudioConfiguration and VideoConfiguration.
  768.         // We ignore the multiplexed audio when there is normal audio also.
  769.         if (videoCodecs.includes(',') && !audio) {
  770.           const allCodecs = videoCodecs.split(',');
  771.           const baseMimeType = MimeUtils.getBasicType(fullMimeType);
  773.           videoCodecs = ManifestParserUtils.guessCodecs(
  774.               ContentType.VIDEO, allCodecs);
  776.           let audioCodecs = ManifestParserUtils.guessCodecs(
  777.               ContentType.AUDIO, allCodecs);
  778.           audioCodecs = StreamUtils.getCorrectAudioCodecs(
  779.               audioCodecs, baseMimeType);
  781.           const audioFullType = MimeUtils.getFullOrConvertedType(
  782.               baseMimeType, audioCodecs, ContentType.AUDIO);
  784.           audioConfigs.push({
  785.             contentType: audioFullType,
  786.             channels: 2,
  787.             bitrate: variant.bandwidth || 1,
  788.             samplerate: 1,
  789.             spatialRendering: false,
  790.           });
  791.         }
  793.         videoCodecs = StreamUtils.getCorrectVideoCodecs(videoCodecs);
  794.         const fullType = MimeUtils.getFullOrConvertedType(
  795.             MimeUtils.getBasicType(fullMimeType), videoCodecs,
  796.             ContentType.VIDEO);
  798.         // VideoConfiguration
  799.         const videoConfig = {
  800.           contentType: fullType,
  802.           // NOTE: Some decoders strictly check the width and height fields and
  803.           // won't decode smaller than 64x64.  So if we don't have this info (as
  804.           // is the case in some of our simpler tests), assume a 64x64
  805.           // resolution to fill in this required field for MediaCapabilities.
  806.           //
  807.           // This became an issue specifically on Firefox on M1 Macs.
  808.           width: video.width || 64,
  809.           height: video.height || 64,
  811.           bitrate: video.bandwidth || variant.bandwidth || 1,
  812.           // framerate must be greater than 0, otherwise the config is invalid.
  813.           framerate: video.frameRate || 1,
  814.         };
  815.         if (video.hdr) {
  816.           switch (video.hdr) {
  817.             case 'SDR':
  818.               videoConfig.transferFunction = 'srgb';
  819.               break;
  820.             case 'PQ':
  821.               videoConfig.transferFunction = 'pq';
  822.               break;
  823.             case 'HLG':
  824.               videoConfig.transferFunction = 'hlg';
  825.               break;
  826.           }
  827.         }
  828.         if (video.colorGamut) {
  829.           videoConfig.colorGamut = video.colorGamut;
  830.         }
  831.         videoConfigs.push(videoConfig);
  832.       }
  833.     }
  834.     if (audio) {
  835.       for (const fullMimeType of audio.fullMimeTypes) {
  836.         const baseMimeType = MimeUtils.getBasicType(fullMimeType);
  837.         const codecs = StreamUtils.getCorrectAudioCodecs(
  838.             MimeUtils.getCodecs(fullMimeType), baseMimeType);
  839.         const fullType = MimeUtils.getFullOrConvertedType(
  840.             baseMimeType, codecs, ContentType.AUDIO);
  842.         // AudioConfiguration
  843.         audioConfigs.push({
  844.           contentType: fullType,
  845.           channels: audio.channelsCount || 2,
  846.           bitrate: audio.bandwidth || variant.bandwidth || 1,
  847.           samplerate: audio.audioSamplingRate || 1,
  848.           spatialRendering: audio.spatialAudio,
  849.         });
  850.       }
  851.     }
  853.     // Generate each combination of video and audio config as a separate
  854.     // MediaDecodingConfiguration, inside the main "batch".
  855.     /** @type {!Array.<!MediaDecodingConfiguration>} */
  856.     const mediaDecodingConfigBatch = [];
  857.     if (videoConfigs.length == 0) {
  858.       videoConfigs.push(null);
  859.     }
  860.     if (audioConfigs.length == 0) {
  861.       audioConfigs.push(null);
  862.     }
  863.     for (const videoConfig of videoConfigs) {
  864.       for (const audioConfig of audioConfigs) {
  865.         /** @type {!MediaDecodingConfiguration} */
  866.         const mediaDecodingConfig = {
  867.           type: srcEquals ? 'file' : 'media-source',
  868.         };
  869.         if (videoConfig) {
  870.           mediaDecodingConfig.video = videoConfig;
  871.         }
  872.         if (audioConfig) {
  873.           mediaDecodingConfig.audio = audioConfig;
  874.         }
  875.         mediaDecodingConfigBatch.push(mediaDecodingConfig);
  876.       }
  877.     }
  879.     const videoDrmInfos = variant.video ? variant.video.drmInfos : [];
  880.     const audioDrmInfos = variant.audio ? variant.audio.drmInfos : [];
  881.     const allDrmInfos = videoDrmInfos.concat(audioDrmInfos);
  883.     // Return a list containing the mediaDecodingConfig for unencrypted variant.
  884.     if (!allDrmInfos.length) {
  885.       return [mediaDecodingConfigBatch];
  886.     }
  888.     // A list of MediaDecodingConfiguration objects created for the variant.
  889.     const configs = [];
  891.     // Get all the drm info so that we can avoid using nested loops when we
  892.     // just need the drm info.
  893.     const drmInfoByKeySystems = new Map();
  894.     for (const info of allDrmInfos) {
  895.       if (!drmInfoByKeySystems.get(info.keySystem)) {
  896.         drmInfoByKeySystems.set(info.keySystem, []);
  897.       }
  898.       drmInfoByKeySystems.get(info.keySystem).push(info);
  899.     }
  901.     const persistentState =
  902.         usePersistentLicenses ? 'required' : 'optional';
  903.     const sessionTypes =
  904.         usePersistentLicenses ? ['persistent-license'] : ['temporary'];
  906.     for (const keySystem of drmInfoByKeySystems.keys()) {
  907.       const modifiedMediaDecodingConfigBatch = [];
  908.       for (const base of mediaDecodingConfigBatch) {
  909.         // Create a copy of the mediaDecodingConfig.
  910.         const config = /** @type {!MediaDecodingConfiguration} */
  911.             (Object.assign({}, base));
  913.         const drmInfos = drmInfoByKeySystems.get(keySystem);
  915.         /** @type {!MediaCapabilitiesKeySystemConfiguration} */
  916.         const keySystemConfig = {
  917.           keySystem: keySystem,
  918.           initDataType: 'cenc',
  919.           persistentState: persistentState,
  920.           distinctiveIdentifier: 'optional',
  921.           sessionTypes: sessionTypes,
  922.         };
  924.         for (const info of drmInfos) {
  925.           if (info.initData && info.initData.length) {
  926.             const initDataTypes = new Set();
  927.             for (const initData of info.initData) {
  928.               initDataTypes.add(initData.initDataType);
  929.             }
  930.             if (initDataTypes.size > 1) {
  931.               shaka.log.v2('DrmInfo contains more than one initDataType,',
  932.                   'and we use the initDataType of the first initData.',
  933.                   info);
  934.             }
  935.             keySystemConfig.initDataType = info.initData[0].initDataType;
  936.           }
  938.           if (info.distinctiveIdentifierRequired) {
  939.             keySystemConfig.distinctiveIdentifier = 'required';
  940.           }
  941.           if (info.persistentStateRequired) {
  942.             keySystemConfig.persistentState = 'required';
  943.           }
  944.           if (info.sessionType) {
  945.             keySystemConfig.sessionTypes = [info.sessionType];
  946.           }
  948.           if (audio) {
  949.             if (!keySystemConfig.audio) {
  950.               // KeySystemTrackConfiguration
  951.               keySystemConfig.audio = {
  952.                 encryptionScheme: info.encryptionScheme,
  953.                 robustness: info.audioRobustness,
  954.               };
  955.             } else {
  956.               keySystemConfig.audio.encryptionScheme =
  957.                   keySystemConfig.audio.encryptionScheme ||
  958.                   info.encryptionScheme;
  959.               keySystemConfig.audio.robustness =
  960.                   keySystemConfig.audio.robustness ||
  961.                   info.audioRobustness;
  962.             }
  963.             // See: https://github.com/shaka-project/shaka-player/issues/4659
  964.             if (keySystemConfig.audio.robustness == '') {
  965.               delete keySystemConfig.audio.robustness;
  966.             }
  967.           }
  969.           if (video) {
  970.             if (!keySystemConfig.video) {
  971.               // KeySystemTrackConfiguration
  972.               keySystemConfig.video = {
  973.                 encryptionScheme: info.encryptionScheme,
  974.                 robustness: info.videoRobustness,
  975.               };
  976.             } else {
  977.               keySystemConfig.video.encryptionScheme =
  978.                   keySystemConfig.video.encryptionScheme ||
  979.                   info.encryptionScheme;
  980.               keySystemConfig.video.robustness =
  981.                   keySystemConfig.video.robustness ||
  982.                   info.videoRobustness;
  983.             }
  984.             // See: https://github.com/shaka-project/shaka-player/issues/4659
  985.             if (keySystemConfig.video.robustness == '') {
  986.               delete keySystemConfig.video.robustness;
  987.             }
  988.           }
  989.         }
  990.         config.keySystemConfiguration = keySystemConfig;
  991.         modifiedMediaDecodingConfigBatch.push(config);
  992.       }
  993.       configs.push(modifiedMediaDecodingConfigBatch);
  994.     }
  995.     return configs;
  996.   }
  999.   /**
  1000.    * Generates the correct audio codec for MediaDecodingConfiguration and
  1001.    * for MediaSource.isTypeSupported.
  1002.    * @param {string} codecs
  1003.    * @param {string} mimeType
  1004.    * @return {string}
  1005.    */
  1006.   static getCorrectAudioCodecs(codecs, mimeType) {
  1007.     // According to RFC 6381 section 3.3, 'fLaC' is actually the correct
  1008.     // codec string. We still need to map it to 'flac', as some browsers
  1009.     // currently don't support 'fLaC', while 'flac' is supported by most
  1010.     // major browsers.
  1011.     // See https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
  1012.     if (codecs.toLowerCase() == 'flac') {
  1013.       if (!shaka.util.Platform.isSafari()) {
  1014.         return 'flac';
  1015.       } else {
  1016.         return 'fLaC';
  1017.       }
  1018.     }
  1020.     // The same is true for 'Opus'.
  1021.     if (codecs.toLowerCase() === 'opus') {
  1022.       if (!shaka.util.Platform.isSafari()) {
  1023.         return 'opus';
  1024.       } else {
  1025.         if (shaka.util.MimeUtils.getContainerType(mimeType) == 'mp4') {
  1026.           return 'Opus';
  1027.         } else {
  1028.           return 'opus';
  1029.         }
  1030.       }
  1031.     }
  1033.     return codecs;
  1034.   }
  1037.   /**
  1038.    * Generates the correct video codec for MediaDecodingConfiguration and
  1039.    * for MediaSource.isTypeSupported.
  1040.    * @param {string} codec
  1041.    * @return {string}
  1042.    */
  1043.   static getCorrectVideoCodecs(codec) {
  1044.     if (codec.includes('avc1')) {
  1045.       // Convert avc1 codec string from RFC-4281 to RFC-6381 for
  1046.       // MediaSource.isTypeSupported
  1047.       // Example, convert avc1.66.30 to avc1.42001e (0x42 == 66 and 0x1e == 30)
  1048.       const avcdata = codec.split('.');
  1049.       if (avcdata.length == 3) {
  1050.         let result = avcdata.shift() + '.';
  1051.         result += parseInt(avcdata.shift(), 10).toString(16);
  1052.         result +=
  1053.             ('000' + parseInt(avcdata.shift(), 10).toString(16)).slice(-4);
  1054.         return result;
  1055.       }
  1056.     } else if (codec == 'vp9') {
  1057.       // MediaCapabilities supports 'vp09...' codecs, but not 'vp9'. Translate
  1058.       // vp9 codec strings into 'vp09...', to allow such content to play with
  1059.       // mediaCapabilities enabled.
  1060.       // This means profile 0, level 4.1, 8-bit color.  This supports 1080p @
  1061.       // 60Hz.  See https://en.wikipedia.org/wiki/VP9#Levels
  1062.       //
  1063.       // If we don't have more detailed codec info, assume this profile and
  1064.       // level because it's high enough to likely accommodate the parameters we
  1065.       // do have, such as width and height.  If an implementation is checking
  1066.       // the profile and level very strictly, we want older VP9 content to
  1067.       // still work to some degree.  But we don't want to set a level so high
  1068.       // that it is rejected by a hardware decoder that can't handle the
  1069.       // maximum requirements of the level.
  1070.       //
  1071.       // This became an issue specifically on Firefox on M1 Macs.
  1072.       return 'vp09.00.41.08';
  1073.     }
  1074.     return codec;
  1075.   }
  1078.   /**
  1079.    * Alters the given Manifest to filter out any streams uncompatible with the
  1080.    * current variant.
  1081.    *
  1082.    * @param {?shaka.extern.Variant} currentVariant
  1083.    * @param {shaka.extern.Manifest} manifest
  1084.    */
  1085.   static filterManifestByCurrentVariant(currentVariant, manifest) {
  1086.     const StreamUtils = shaka.util.StreamUtils;
  1087.     manifest.variants = manifest.variants.filter((variant) => {
  1088.       const audio = variant.audio;
  1089.       const video = variant.video;
  1090.       if (audio && currentVariant && currentVariant.audio) {
  1091.         if (!StreamUtils.areStreamsCompatible_(audio, currentVariant.audio)) {
  1092.           shaka.log.debug('Dropping variant - not compatible with active audio',
  1093.               'active audio',
  1094.               StreamUtils.getStreamSummaryString_(currentVariant.audio),
  1095.               'variant.audio',
  1096.               StreamUtils.getStreamSummaryString_(audio));
  1097.           return false;
  1098.         }
  1099.       }
  1101.       if (video && currentVariant && currentVariant.video) {
  1102.         if (!StreamUtils.areStreamsCompatible_(video, currentVariant.video)) {
  1103.           shaka.log.debug('Dropping variant - not compatible with active video',
  1104.               'active video',
  1105.               StreamUtils.getStreamSummaryString_(currentVariant.video),
  1106.               'variant.video',
  1107.               StreamUtils.getStreamSummaryString_(video));
  1108.           return false;
  1109.         }
  1110.       }
  1112.       return true;
  1113.     });
  1114.   }
  1116.   /**
  1117.    * Alters the given Manifest to filter out any unsupported text streams.
  1118.    *
  1119.    * @param {shaka.extern.Manifest} manifest
  1120.    * @private
  1121.    */
  1122.   static filterTextStreams_(manifest) {
  1123.     // Filter text streams.
  1124.     manifest.textStreams = manifest.textStreams.filter((stream) => {
  1125.       const fullMimeType = shaka.util.MimeUtils.getFullType(
  1126.           stream.mimeType, stream.codecs);
  1127.       const keep = shaka.text.TextEngine.isTypeSupported(fullMimeType);
  1129.       if (!keep) {
  1130.         shaka.log.debug('Dropping text stream. Is not supported by the ' +
  1131.                         'platform.', stream);
  1132.       }
  1134.       return keep;
  1135.     });
  1136.   }
  1139.   /**
  1140.    * Alters the given Manifest to filter out any unsupported image streams.
  1141.    *
  1142.    * @param {shaka.extern.Manifest} manifest
  1143.    * @private
  1144.    */
  1145.   static async filterImageStreams_(manifest) {
  1146.     const imageStreams = [];
  1147.     for (const stream of manifest.imageStreams) {
  1148.       let mimeType = stream.mimeType;
  1149.       if (mimeType == 'application/mp4' && stream.codecs == 'mjpg') {
  1150.         mimeType = 'image/jpg';
  1151.       }
  1152.       if (!shaka.util.StreamUtils.supportedImageMimeTypes_.has(mimeType)) {
  1153.         const minImage = shaka.util.StreamUtils.minImage_.get(mimeType);
  1154.         if (minImage) {
  1155.           // eslint-disable-next-line no-await-in-loop
  1156.           const res = await shaka.util.StreamUtils.isImageSupported_(minImage);
  1157.           shaka.util.StreamUtils.supportedImageMimeTypes_.set(mimeType, res);
  1158.         } else {
  1159.           shaka.util.StreamUtils.supportedImageMimeTypes_.set(mimeType, false);
  1160.         }
  1161.       }
  1163.       const keep =
  1164.           shaka.util.StreamUtils.supportedImageMimeTypes_.get(mimeType);
  1166.       if (!keep) {
  1167.         shaka.log.debug('Dropping image stream. Is not supported by the ' +
  1168.                         'platform.', stream);
  1169.       } else {
  1170.         imageStreams.push(stream);
  1171.       }
  1172.     }
  1173.     manifest.imageStreams = imageStreams;
  1174.   }
  1176.   /**
  1177.    * @param {string} minImage
  1178.    * @return {!Promise.<boolean>}
  1179.    * @private
  1180.    */
  1181.   static isImageSupported_(minImage) {
  1182.     return new Promise((resolve) => {
  1183.       const imageElement = /** @type {HTMLImageElement} */(new Image());
  1184.       imageElement.src = minImage;
  1185.       if ('decode' in imageElement) {
  1186.         imageElement.decode().then(() => {
  1187.           resolve(true);
  1188.         }).catch(() => {
  1189.           resolve(false);
  1190.         });
  1191.       } else {
  1192.         imageElement.onload = imageElement.onerror = () => {
  1193.           resolve(imageElement.height === 2);
  1194.         };
  1195.       }
  1196.     });
  1197.   }
  1199.   /**
  1200.    * @param {shaka.extern.Stream} s0
  1201.    * @param {shaka.extern.Stream} s1
  1202.    * @return {boolean}
  1203.    * @private
  1204.    */
  1205.   static areStreamsCompatible_(s0, s1) {
  1206.     // Basic mime types and basic codecs need to match.
  1207.     // For example, we can't adapt between WebM and MP4,
  1208.     // nor can we adapt between mp4a.* to ec-3.
  1209.     // We can switch between text types on the fly,
  1210.     // so don't run this check on text.
  1211.     if (s0.mimeType != s1.mimeType) {
  1212.       return false;
  1213.     }
  1215.     if (s0.codecs.split('.')[0] != s1.codecs.split('.')[0]) {
  1216.       return false;
  1217.     }
  1219.     return true;
  1220.   }
  1223.   /**
  1224.    * @param {shaka.extern.Variant} variant
  1225.    * @return {shaka.extern.Track}
  1226.    */
  1227.   static variantToTrack(variant) {
  1228.     /** @type {?shaka.extern.Stream} */
  1229.     const audio = variant.audio;
  1230.     /** @type {?shaka.extern.Stream} */
  1231.     const video = variant.video;
  1233.     /** @type {?string} */
  1234.     const audioMimeType = audio ? audio.mimeType : null;
  1235.     /** @type {?string} */
  1236.     const videoMimeType = video ? video.mimeType : null;
  1238.     /** @type {?string} */
  1239.     const audioCodec = audio ? audio.codecs : null;
  1240.     /** @type {?string} */
  1241.     const videoCodec = video ? video.codecs : null;
  1243.     /** @type {!Array.<string>} */
  1244.     const codecs = [];
  1245.     if (videoCodec) {
  1246.       codecs.push(videoCodec);
  1247.     }
  1248.     if (audioCodec) {
  1249.       codecs.push(audioCodec);
  1250.     }
  1252.     /** @type {!Array.<string>} */
  1253.     const mimeTypes = [];
  1254.     if (video) {
  1255.       mimeTypes.push(video.mimeType);
  1256.     }
  1257.     if (audio) {
  1258.       mimeTypes.push(audio.mimeType);
  1259.     }
  1260.     /** @type {?string} */
  1261.     const mimeType = mimeTypes[0] || null;
  1263.     /** @type {!Array.<string>} */
  1264.     const kinds = [];
  1265.     if (audio) {
  1266.       kinds.push(audio.kind);
  1267.     }
  1268.     if (video) {
  1269.       kinds.push(video.kind);
  1270.     }
  1271.     /** @type {?string} */
  1272.     const kind = kinds[0] || null;
  1274.     /** @type {!Set.<string>} */
  1275.     const roles = new Set();
  1276.     if (audio) {
  1277.       for (const role of audio.roles) {
  1278.         roles.add(role);
  1279.       }
  1280.     }
  1281.     if (video) {
  1282.       for (const role of video.roles) {
  1283.         roles.add(role);
  1284.       }
  1285.     }
  1287.     /** @type {shaka.extern.Track} */
  1288.     const track = {
  1289.       id: variant.id,
  1290.       active: false,
  1291.       type: 'variant',
  1292.       bandwidth: variant.bandwidth,
  1293.       language: variant.language,
  1294.       label: null,
  1295.       kind: kind,
  1296.       width: null,
  1297.       height: null,
  1298.       frameRate: null,
  1299.       pixelAspectRatio: null,
  1300.       hdr: null,
  1301.       colorGamut: null,
  1302.       videoLayout: null,
  1303.       mimeType: mimeType,
  1304.       audioMimeType: audioMimeType,
  1305.       videoMimeType: videoMimeType,
  1306.       codecs: codecs.join(', '),
  1307.       audioCodec: audioCodec,
  1308.       videoCodec: videoCodec,
  1309.       primary: variant.primary,
  1310.       roles: Array.from(roles),
  1311.       audioRoles: null,
  1312.       forced: false,
  1313.       videoId: null,
  1314.       audioId: null,
  1315.       channelsCount: null,
  1316.       audioSamplingRate: null,
  1317.       spatialAudio: false,
  1318.       tilesLayout: null,
  1319.       audioBandwidth: null,
  1320.       videoBandwidth: null,
  1321.       originalVideoId: null,
  1322.       originalAudioId: null,
  1323.       originalTextId: null,
  1324.       originalImageId: null,
  1325.       accessibilityPurpose: null,
  1326.       originalLanguage: null,
  1327.     };
  1329.     if (video) {
  1330.       track.videoId = video.id;
  1331.       track.originalVideoId = video.originalId;
  1332.       track.width = video.width || null;
  1333.       track.height = video.height || null;
  1334.       track.frameRate = video.frameRate || null;
  1335.       track.pixelAspectRatio = video.pixelAspectRatio || null;
  1336.       track.videoBandwidth = video.bandwidth || null;
  1337.       track.hdr = video.hdr || null;
  1338.       track.colorGamut = video.colorGamut || null;
  1339.       track.videoLayout = video.videoLayout || null;
  1340.     }
  1342.     if (audio) {
  1343.       track.audioId = audio.id;
  1344.       track.originalAudioId = audio.originalId;
  1345.       track.channelsCount = audio.channelsCount;
  1346.       track.audioSamplingRate = audio.audioSamplingRate;
  1347.       track.audioBandwidth = audio.bandwidth || null;
  1348.       track.spatialAudio = audio.spatialAudio;
  1349.       track.label = audio.label;
  1350.       track.audioRoles = audio.roles;
  1351.       track.accessibilityPurpose = audio.accessibilityPurpose;
  1352.       track.originalLanguage = audio.originalLanguage;
  1353.     }
  1355.     return track;
  1356.   }
  1359.   /**
  1360.    * @param {shaka.extern.Stream} stream
  1361.    * @return {shaka.extern.Track}
  1362.    */
  1363.   static textStreamToTrack(stream) {
  1364.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1366.     /** @type {shaka.extern.Track} */
  1367.     const track = {
  1368.       id: stream.id,
  1369.       active: false,
  1370.       type: ContentType.TEXT,
  1371.       bandwidth: 0,
  1372.       language: stream.language,
  1373.       label: stream.label,
  1374.       kind: stream.kind || null,
  1375.       width: null,
  1376.       height: null,
  1377.       frameRate: null,
  1378.       pixelAspectRatio: null,
  1379.       hdr: null,
  1380.       colorGamut: null,
  1381.       videoLayout: null,
  1382.       mimeType: stream.mimeType,
  1383.       audioMimeType: null,
  1384.       videoMimeType: null,
  1385.       codecs: stream.codecs || null,
  1386.       audioCodec: null,
  1387.       videoCodec: null,
  1388.       primary: stream.primary,
  1389.       roles: stream.roles,
  1390.       audioRoles: null,
  1391.       forced: stream.forced,
  1392.       videoId: null,
  1393.       audioId: null,
  1394.       channelsCount: null,
  1395.       audioSamplingRate: null,
  1396.       spatialAudio: false,
  1397.       tilesLayout: null,
  1398.       audioBandwidth: null,
  1399.       videoBandwidth: null,
  1400.       originalVideoId: null,
  1401.       originalAudioId: null,
  1402.       originalTextId: stream.originalId,
  1403.       originalImageId: null,
  1404.       accessibilityPurpose: stream.accessibilityPurpose,
  1405.       originalLanguage: stream.originalLanguage,
  1406.     };
  1408.     return track;
  1409.   }
  1412.   /**
  1413.    * @param {shaka.extern.Stream} stream
  1414.    * @return {shaka.extern.Track}
  1415.    */
  1416.   static imageStreamToTrack(stream) {
  1417.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1419.     let width = stream.width || null;
  1420.     let height = stream.height || null;
  1422.     // The stream width and height represent the size of the entire thumbnail
  1423.     // sheet, so divide by the layout.
  1424.     let reference = null;
  1425.     // Note: segmentIndex is built by default for HLS, but not for DASH, but
  1426.     // in DASH this information comes at the stream level and not at the
  1427.     // segment level.
  1428.     if (stream.segmentIndex) {
  1429.       reference = stream.segmentIndex.get(0);
  1430.     }
  1431.     let layout = stream.tilesLayout;
  1432.     if (reference) {
  1433.       layout = reference.getTilesLayout() || layout;
  1434.     }
  1435.     if (layout && width != null) {
  1436.       width /= Number(layout.split('x')[0]);
  1437.     }
  1438.     if (layout && height != null) {
  1439.       height /= Number(layout.split('x')[1]);
  1440.     }
  1441.     // TODO: What happens if there are multiple grids, with different
  1442.     // layout sizes, inside this image stream?
  1444.     /** @type {shaka.extern.Track} */
  1445.     const track = {
  1446.       id: stream.id,
  1447.       active: false,
  1448.       type: ContentType.IMAGE,
  1449.       bandwidth: stream.bandwidth || 0,
  1450.       language: '',
  1451.       label: null,
  1452.       kind: null,
  1453.       width,
  1454.       height,
  1455.       frameRate: null,
  1456.       pixelAspectRatio: null,
  1457.       hdr: null,
  1458.       colorGamut: null,
  1459.       videoLayout: null,
  1460.       mimeType: stream.mimeType,
  1461.       audioMimeType: null,
  1462.       videoMimeType: null,
  1463.       codecs: stream.codecs || null,
  1464.       audioCodec: null,
  1465.       videoCodec: null,
  1466.       primary: false,
  1467.       roles: [],
  1468.       audioRoles: null,
  1469.       forced: false,
  1470.       videoId: null,
  1471.       audioId: null,
  1472.       channelsCount: null,
  1473.       audioSamplingRate: null,
  1474.       spatialAudio: false,
  1475.       tilesLayout: layout || null,
  1476.       audioBandwidth: null,
  1477.       videoBandwidth: null,
  1478.       originalVideoId: null,
  1479.       originalAudioId: null,
  1480.       originalTextId: null,
  1481.       originalImageId: stream.originalId,
  1482.       accessibilityPurpose: null,
  1483.       originalLanguage: null,
  1484.     };
  1486.     return track;
  1487.   }
  1490.   /**
  1491.    * Generate and return an ID for this track, since the ID field is optional.
  1492.    *
  1493.    * @param {TextTrack|AudioTrack} html5Track
  1494.    * @return {number} The generated ID.
  1495.    */
  1496.   static html5TrackId(html5Track) {
  1497.     if (!html5Track['__shaka_id']) {
  1498.       html5Track['__shaka_id'] = shaka.util.StreamUtils.nextTrackId_++;
  1499.     }
  1500.     return html5Track['__shaka_id'];
  1501.   }
  1504.   /**
  1505.    * @param {TextTrack} textTrack
  1506.    * @return {shaka.extern.Track}
  1507.    */
  1508.   static html5TextTrackToTrack(textTrack) {
  1509.     const StreamUtils = shaka.util.StreamUtils;
  1511.     /** @type {shaka.extern.Track} */
  1512.     const track = StreamUtils.html5TrackToGenericShakaTrack_(textTrack);
  1513.     track.active = textTrack.mode != 'disabled';
  1514.     track.type = 'text';
  1515.     track.originalTextId = textTrack.id;
  1516.     if (textTrack.kind == 'captions') {
  1517.       // See: https://github.com/shaka-project/shaka-player/issues/6233
  1518.       track.mimeType = 'unknown';
  1519.     }
  1520.     if (textTrack.kind == 'subtitles') {
  1521.       track.mimeType = 'text/vtt';
  1522.     }
  1523.     if (textTrack.kind) {
  1524.       track.roles = [textTrack.kind];
  1525.     }
  1526.     if (textTrack.kind == 'forced') {
  1527.       track.forced = true;
  1528.     }
  1530.     return track;
  1531.   }
  1534.   /**
  1535.    * @param {AudioTrack} audioTrack
  1536.    * @return {shaka.extern.Track}
  1537.    */
  1538.   static html5AudioTrackToTrack(audioTrack) {
  1539.     const StreamUtils = shaka.util.StreamUtils;
  1541.     /** @type {shaka.extern.Track} */
  1542.     const track = StreamUtils.html5TrackToGenericShakaTrack_(audioTrack);
  1543.     track.active = audioTrack.enabled;
  1544.     track.type = 'variant';
  1545.     track.originalAudioId = audioTrack.id;
  1547.     if (audioTrack.kind == 'main') {
  1548.       track.primary = true;
  1549.     }
  1550.     if (audioTrack.kind) {
  1551.       track.roles = [audioTrack.kind];
  1552.       track.audioRoles = [audioTrack.kind];
  1553.       track.label = audioTrack.label;
  1554.     }
  1556.     return track;
  1557.   }
  1560.   /**
  1561.    * Creates a Track object with non-type specific fields filled out.  The
  1562.    * caller is responsible for completing the Track object with any
  1563.    * type-specific information (audio or text).
  1564.    *
  1565.    * @param {TextTrack|AudioTrack} html5Track
  1566.    * @return {shaka.extern.Track}
  1567.    * @private
  1568.    */
  1569.   static html5TrackToGenericShakaTrack_(html5Track) {
  1570.     const language = html5Track.language;
  1572.     /** @type {shaka.extern.Track} */
  1573.     const track = {
  1574.       id: shaka.util.StreamUtils.html5TrackId(html5Track),
  1575.       active: false,
  1576.       type: '',
  1577.       bandwidth: 0,
  1578.       language: shaka.util.LanguageUtils.normalize(language || 'und'),
  1579.       label: html5Track.label,
  1580.       kind: html5Track.kind,
  1581.       width: null,
  1582.       height: null,
  1583.       frameRate: null,
  1584.       pixelAspectRatio: null,
  1585.       hdr: null,
  1586.       colorGamut: null,
  1587.       videoLayout: null,
  1588.       mimeType: null,
  1589.       audioMimeType: null,
  1590.       videoMimeType: null,
  1591.       codecs: null,
  1592.       audioCodec: null,
  1593.       videoCodec: null,
  1594.       primary: false,
  1595.       roles: [],
  1596.       forced: false,
  1597.       audioRoles: null,
  1598.       videoId: null,
  1599.       audioId: null,
  1600.       channelsCount: null,
  1601.       audioSamplingRate: null,
  1602.       spatialAudio: false,
  1603.       tilesLayout: null,
  1604.       audioBandwidth: null,
  1605.       videoBandwidth: null,
  1606.       originalVideoId: null,
  1607.       originalAudioId: null,
  1608.       originalTextId: null,
  1609.       originalImageId: null,
  1610.       accessibilityPurpose: null,
  1611.       originalLanguage: language,
  1612.     };
  1614.     return track;
  1615.   }
  1618.   /**
  1619.    * Determines if the given variant is playable.
  1620.    * @param {!shaka.extern.Variant} variant
  1621.    * @return {boolean}
  1622.    */
  1623.   static isPlayable(variant) {
  1624.     return variant.allowedByApplication &&
  1625.         variant.allowedByKeySystem &&
  1626.         variant.disabledUntilTime == 0;
  1627.   }
  1630.   /**
  1631.    * Filters out unplayable variants.
  1632.    * @param {!Array.<!shaka.extern.Variant>} variants
  1633.    * @return {!Array.<!shaka.extern.Variant>}
  1634.    */
  1635.   static getPlayableVariants(variants) {
  1636.     return variants.filter((variant) => {
  1637.       return shaka.util.StreamUtils.isPlayable(variant);
  1638.     });
  1639.   }
  1642.   /**
  1643.    * Chooses streams according to the given config.
  1644.    * Works both for Stream and Track types due to their similarities.
  1645.    *
  1646.    * @param {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>} streams
  1647.    * @param {string} preferredLanguage
  1648.    * @param {string} preferredRole
  1649.    * @param {boolean} preferredForced
  1650.    * @return {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>}
  1651.    */
  1652.   static filterStreamsByLanguageAndRole(
  1653.       streams, preferredLanguage, preferredRole, preferredForced) {
  1654.     const LanguageUtils = shaka.util.LanguageUtils;
  1656.     /** @type {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>} */
  1657.     let chosen = streams;
  1659.     // Start with the set of primary streams.
  1660.     /** @type {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>} */
  1661.     const primary = streams.filter((stream) => {
  1662.       return stream.primary;
  1663.     });
  1665.     if (primary.length) {
  1666.       chosen = primary;
  1667.     }
  1669.     // Now reduce the set to one language.  This covers both arbitrary language
  1670.     // choice and the reduction of the "primary" stream set to one language.
  1671.     const firstLanguage = chosen.length ? chosen[0].language : '';
  1672.     chosen = chosen.filter((stream) => {
  1673.       return stream.language == firstLanguage;
  1674.     });
  1676.     // Find the streams that best match our language preference. This will
  1677.     // override previous selections.
  1678.     if (preferredLanguage) {
  1679.       const closestLocale = LanguageUtils.findClosestLocale(
  1680.           LanguageUtils.normalize(preferredLanguage),
  1681.           streams.map((stream) => stream.language));
  1683.       // Only replace |chosen| if we found a locale that is close to our
  1684.       // preference.
  1685.       if (closestLocale) {
  1686.         chosen = streams.filter((stream) => {
  1687.           const locale = LanguageUtils.normalize(stream.language);
  1688.           return locale == closestLocale;
  1689.         });
  1690.       }
  1691.     }
  1693.     // Filter by forced preference
  1694.     chosen = chosen.filter((stream) => {
  1695.       return stream.forced == preferredForced;
  1696.     });
  1698.     // Now refine the choice based on role preference.
  1699.     if (preferredRole) {
  1700.       const roleMatches = shaka.util.StreamUtils.filterStreamsByRole_(
  1701.           chosen, preferredRole);
  1702.       if (roleMatches.length) {
  1703.         return roleMatches;
  1704.       } else {
  1705.         shaka.log.warning('No exact match for the text role could be found.');
  1706.       }
  1707.     } else {
  1708.       // Prefer text streams with no roles, if they exist.
  1709.       const noRoleMatches = chosen.filter((stream) => {
  1710.         return stream.roles.length == 0;
  1711.       });
  1712.       if (noRoleMatches.length) {
  1713.         return noRoleMatches;
  1714.       }
  1715.     }
  1717.     // Either there was no role preference, or it could not be satisfied.
  1718.     // Choose an arbitrary role, if there are any, and filter out any other
  1719.     // roles. This ensures we never adapt between roles.
  1721.     const allRoles = chosen.map((stream) => {
  1722.       return stream.roles;
  1723.     }).reduce(shaka.util.Functional.collapseArrays, []);
  1725.     if (!allRoles.length) {
  1726.       return chosen;
  1727.     }
  1728.     return shaka.util.StreamUtils.filterStreamsByRole_(chosen, allRoles[0]);
  1729.   }
  1732.   /**
  1733.    * Filter Streams by role.
  1734.    * Works both for Stream and Track types due to their similarities.
  1735.    *
  1736.    * @param {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>} streams
  1737.    * @param {string} preferredRole
  1738.    * @return {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>}
  1739.    * @private
  1740.    */
  1741.   static filterStreamsByRole_(streams, preferredRole) {
  1742.     return streams.filter((stream) => {
  1743.       return stream.roles.includes(preferredRole);
  1744.     });
  1745.   }
  1748.   /**
  1749.    * Checks if the given stream is an audio stream.
  1750.    *
  1751.    * @param {shaka.extern.Stream} stream
  1752.    * @return {boolean}
  1753.    */
  1754.   static isAudio(stream) {
  1755.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1756.     return stream.type == ContentType.AUDIO;
  1757.   }
  1760.   /**
  1761.    * Checks if the given stream is a video stream.
  1762.    *
  1763.    * @param {shaka.extern.Stream} stream
  1764.    * @return {boolean}
  1765.    */
  1766.   static isVideo(stream) {
  1767.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1768.     return stream.type == ContentType.VIDEO;
  1769.   }
  1772.   /**
  1773.    * Get all non-null streams in the variant as an array.
  1774.    *
  1775.    * @param {shaka.extern.Variant} variant
  1776.    * @return {!Array.<shaka.extern.Stream>}
  1777.    */
  1778.   static getVariantStreams(variant) {
  1779.     const streams = [];
  1781.     if (variant.audio) {
  1782.       streams.push(variant.audio);
  1783.     }
  1784.     if (variant.video) {
  1785.       streams.push(variant.video);
  1786.     }
  1788.     return streams;
  1789.   }
  1792.   /**
  1793.    * Indicates if some of the variant's streams are fastSwitching.
  1794.    *
  1795.    * @param {shaka.extern.Variant} variant
  1796.    * @return {boolean}
  1797.    */
  1798.   static isFastSwitching(variant) {
  1799.     if (variant.audio && variant.audio.fastSwitching) {
  1800.       return true;
  1801.     }
  1802.     if (variant.video && variant.video.fastSwitching) {
  1803.       return true;
  1804.     }
  1805.     return false;
  1806.   }
  1809.   /**
  1810.    * Returns a string of a variant, with the attribute values of its audio
  1811.    * and/or video streams for log printing.
  1812.    * @param {shaka.extern.Variant} variant
  1813.    * @return {string}
  1814.    * @private
  1815.    */
  1816.   static getVariantSummaryString_(variant) {
  1817.     const summaries = [];
  1818.     if (variant.audio) {
  1819.       summaries.push(shaka.util.StreamUtils.getStreamSummaryString_(
  1820.           variant.audio));
  1821.     }
  1822.     if (variant.video) {
  1823.       summaries.push(shaka.util.StreamUtils.getStreamSummaryString_(
  1824.           variant.video));
  1825.     }
  1826.     return summaries.join(', ');
  1827.   }
  1829.   /**
  1830.    * Returns a string of an audio or video stream for log printing.
  1831.    * @param {shaka.extern.Stream} stream
  1832.    * @return {string}
  1833.    * @private
  1834.    */
  1835.   static getStreamSummaryString_(stream) {
  1836.     // Accepted parameters for Chromecast can be found (internally) at
  1837.     // go/cast-mime-params
  1839.     if (shaka.util.StreamUtils.isAudio(stream)) {
  1840.       return 'type=audio' +
  1841.              ' codecs=' + stream.codecs +
  1842.              ' bandwidth='+ stream.bandwidth +
  1843.              ' channelsCount=' + stream.channelsCount +
  1844.              ' audioSamplingRate=' + stream.audioSamplingRate;
  1845.     }
  1847.     if (shaka.util.StreamUtils.isVideo(stream)) {
  1848.       return 'type=video' +
  1849.              ' codecs=' + stream.codecs +
  1850.              ' bandwidth=' + stream.bandwidth +
  1851.              ' frameRate=' + stream.frameRate +
  1852.              ' width=' + stream.width +
  1853.              ' height=' + stream.height;
  1854.     }
  1856.     return 'unexpected stream type';
  1857.   }
  1860.   /**
  1861.    * Clears underlying decoding config cache.
  1862.    */
  1863.   static clearDecodingConfigCache() {
  1864.     shaka.util.StreamUtils.decodingConfigCache_ = {};
  1865.   }
  1866. };
  1869. /**
  1870.  * A cache of results from mediaCapabilities.decodingInfo, indexed by the
  1871.  * (stringified) decodingConfig.
  1872.  *
  1873.  * @type {Object.<(!string), (!MediaCapabilitiesDecodingInfo)>}
  1874.  * @private
  1875.  */
  1876. shaka.util.StreamUtils.decodingConfigCache_ = {};
  1879. /** @private {number} */
  1880. shaka.util.StreamUtils.nextTrackId_ = 0;
  1882. /**
  1883.  * @enum {string}
  1884.  */
  1885. shaka.util.StreamUtils.DecodingAttributes = {
  1886.   SMOOTH: 'smooth',
  1887.   POWER: 'powerEfficient',
  1888. };
  1890. /**
  1891.  * @private {!Map.<string, boolean>}
  1892.  */
  1893. shaka.util.StreamUtils.supportedImageMimeTypes_ = new Map()
  1894.     .set('image/svg+xml', true)
  1895.     .set('image/png', true)
  1896.     .set('image/jpeg', true)
  1897.     .set('image/jpg', true);
  1899. /**
  1900.  * @const {string}
  1901.  * @private
  1902.  */
  1903. shaka.util.StreamUtils.minWebPImage_ = 'data:image/webp;base64,UklGRjoAAABXRU' +
  1904.     'JQVlA4IC4AAACyAgCdASoCAAIALmk0mk0iIiIiIgBoSygABc6WWgAA/veff/0PP8bA//LwY' +
  1905.     'AAA';
  1907. /**
  1908.  * @const {string}
  1909.  * @private
  1910.  */
  1911. shaka.util.StreamUtils.minAvifImage_ = 'data:image/avif;base64,AAAAIGZ0eXBhdm' +
  1912.     'lmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljd' +
  1913.     'AAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEA' +
  1914.     'AAABAAABGgAAAB0AAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAA' +
  1915.     'AamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAIAAAACAAAAEHBpeGkAAAAAAwgICAAAAA' +
  1916.     'xhdjFDgQ0MAAAAABNjb2xybmNseAACAAIAAYAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAA' +
  1917.     'CVtZGF0EgAKCBgANogQEAwgMg8f8D///8WfhwB8+ErK42A=';
  1919. /**
  1920.  * @const {!Map.<string, string>}
  1921.  * @private
  1922.  */
  1923. shaka.util.StreamUtils.minImage_ = new Map()
  1924.     .set('image/webp', shaka.util.StreamUtils.minWebPImage_)
  1925.     .set('image/avif', shaka.util.StreamUtils.minAvifImage_);