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.config.AutoShowText');
  11. goog.require('shaka.lcevc.Dec');
  12. goog.require('shaka.log');
  13. goog.require('shaka.media.Capabilities');
  14. goog.require('shaka.text.TextEngine');
  15. goog.require('shaka.util.Functional');
  16. goog.require('shaka.util.LanguageUtils');
  17. goog.require('shaka.util.ManifestParserUtils');
  18. goog.require('shaka.util.MimeUtils');
  19. goog.require('shaka.util.MultiMap');
  20. goog.require('shaka.util.ObjectUtils');
  21. goog.require('shaka.util.Platform');
  22. goog.requireType('shaka.drm.DrmEngine');
  25. /**
  26.  * @summary A set of utility functions for dealing with Streams and Manifests.
  27.  * @export
  28.  */
  29. shaka.util.StreamUtils = class {
  30.   /**
  31.    * In case of multiple usable codecs, choose one based on lowest average
  32.    * bandwidth and filter out the rest.
  33.    * Also filters out variants that have too many audio channels.
  34.    * @param {!shaka.extern.Manifest} manifest
  35.    * @param {!Array<string>} preferredVideoCodecs
  36.    * @param {!Array<string>} preferredAudioCodecs
  37.    * @param {!Array<string>} preferredDecodingAttributes
  38.    * @param {!Array<string>} preferredTextFormats
  39.    */
  40.   static chooseCodecsAndFilterManifest(manifest, preferredVideoCodecs,
  41.       preferredAudioCodecs, preferredDecodingAttributes, preferredTextFormats) {
  42.     const StreamUtils = shaka.util.StreamUtils;
  43.     const MimeUtils = shaka.util.MimeUtils;
  45.     if (preferredTextFormats.length) {
  46.       let subset = manifest.textStreams;
  47.       for (const textFormat of preferredTextFormats) {
  48.         const filtered = subset.filter((textStream) => {
  49.           if (textStream.codecs.startsWith(textFormat) ||
  50.               textStream.mimeType.startsWith(textFormat)) {
  51.             return true;
  52.           }
  53.           return false;
  54.         });
  55.         if (filtered.length) {
  56.           subset = filtered;
  57.           break;
  58.         }
  59.       }
  60.       manifest.textStreams = subset;
  61.     }
  63.     let variants = manifest.variants;
  64.     // To start, choose the codecs based on configured preferences if available.
  65.     if (preferredVideoCodecs.length || preferredAudioCodecs.length) {
  66.       variants = StreamUtils.choosePreferredCodecs(variants,
  67.           preferredVideoCodecs, preferredAudioCodecs);
  68.     }
  70.     if (preferredDecodingAttributes.length) {
  71.       // group variants by resolution and choose preferred variants only
  72.       /** @type {!shaka.util.MultiMap<shaka.extern.Variant>} */
  73.       const variantsByResolutionMap = new shaka.util.MultiMap();
  74.       for (const variant of variants) {
  75.         variantsByResolutionMap
  76.             .push(String(variant.video.width || 0), variant);
  77.       }
  78.       const bestVariants = [];
  79.       variantsByResolutionMap.forEach((width, variantsByResolution) => {
  80.         let highestMatch = 0;
  81.         let matchingVariants = [];
  82.         for (const variant of variantsByResolution) {
  83.           const matchCount = preferredDecodingAttributes.filter(
  84.               (attribute) => variant.decodingInfos[0][attribute],
  85.           ).length;
  86.           if (matchCount > highestMatch) {
  87.             highestMatch = matchCount;
  88.             matchingVariants = [variant];
  89.           } else if (matchCount == highestMatch) {
  90.             matchingVariants.push(variant);
  91.           }
  92.         }
  93.         bestVariants.push(...matchingVariants);
  94.       });
  95.       variants = bestVariants;
  96.     }
  98.     const audioStreamsSet = new Set();
  99.     const videoStreamsSet = new Set();
  100.     for (const variant of variants) {
  101.       if (variant.audio) {
  102.         audioStreamsSet.add(variant.audio);
  103.       }
  104.       if (variant.video) {
  105.         videoStreamsSet.add(variant.video);
  106.       }
  107.     }
  109.     const audioStreams = Array.from(audioStreamsSet).sort((v1, v2) => {
  110.       return v1.bandwidth - v2.bandwidth;
  111.     });
  112.     const validAudioIds = [];
  113.     const validAudioStreamsMap = new Map();
  114.     const getAudioId = (stream) => {
  115.       let id = stream.language + (stream.channelsCount || 0) +
  116.         (stream.audioSamplingRate || 0) + stream.roles.join(',') +
  117.         stream.label + stream.groupId + stream.fastSwitching;
  118.       if (stream.dependencyStream) {
  119.         id += stream.dependencyStream.baseOriginalId || '';
  120.       }
  121.       return id;
  122.     };
  123.     for (const stream of audioStreams) {
  124.       const groupId = getAudioId(stream);
  125.       const validAudioStreams = validAudioStreamsMap.get(groupId) || [];
  126.       if (!validAudioStreams.length) {
  127.         validAudioStreams.push(stream);
  128.         validAudioIds.push(stream.id);
  129.       } else {
  130.         const previousStream = validAudioStreams[validAudioStreams.length - 1];
  131.         const previousCodec =
  132.           MimeUtils.getNormalizedCodec(previousStream.codecs);
  133.         const currentCodec =
  134.           MimeUtils.getNormalizedCodec(stream.codecs);
  135.         if (previousCodec == currentCodec) {
  136.           if (!stream.bandwidth || !previousStream.bandwidth ||
  137.               stream.bandwidth > previousStream.bandwidth) {
  138.             validAudioStreams.push(stream);
  139.             validAudioIds.push(stream.id);
  140.           }
  141.         }
  142.       }
  143.       validAudioStreamsMap.set(groupId, validAudioStreams);
  144.     }
  146.     // Keys based in MimeUtils.getNormalizedCodec. Lower is better
  147.     const videoCodecPreference = {
  148.       'vp8': 1,
  149.       'avc': 1,
  150.       'dovi-avc': 0.95,
  151.       'vp9': 0.9,
  152.       'vp09': 0.9,
  153.       'hevc': 0.85,
  154.       'dovi-hevc': 0.8,
  155.       'dovi-p5': 0.75,
  156.       'av01': 0.7,
  157.       'dovi-av1': 0.65,
  158.       'vvc': 0.6,
  159.     };
  161.     const videoStreams = Array.from(videoStreamsSet)
  162.         .sort((v1, v2) => {
  163.           if (!v1.bandwidth || !v2.bandwidth || v1.bandwidth == v2.bandwidth) {
  164.             if (v1.codecs && v2.codecs && v1.codecs != v2.codecs &&
  165.                 v1.width == v2.width) {
  166.               const v1Codecs = MimeUtils.getNormalizedCodec(v1.codecs);
  167.               const v2Codecs = MimeUtils.getNormalizedCodec(v2.codecs);
  168.               if (v1Codecs != v2Codecs) {
  169.                 const indexV1 = videoCodecPreference[v1Codecs] || 1;
  170.                 const indexV2 = videoCodecPreference[v2Codecs] || 1;
  171.                 return indexV1 - indexV2;
  172.               }
  173.             }
  174.             return v1.width - v2.width;
  175.           }
  176.           return v1.bandwidth - v2.bandwidth;
  177.         });
  179.     const isChangeTypeSupported =
  180.       shaka.media.Capabilities.isChangeTypeSupported();
  182.     const validVideoIds = [];
  183.     const validVideoStreamsMap = new Map();
  184.     const getVideoGroupId = (stream) => {
  185.       let id = String(stream.width || '') + String(stream.height || '') +
  186.           String(Math.round(stream.frameRate || 0)) + (stream.hdr || '') +
  187.           stream.fastSwitching;
  188.       if (stream.dependencyStream) {
  189.         id += stream.dependencyStream.baseOriginalId || '';
  190.       }
  191.       return id;
  192.     };
  193.     for (const stream of videoStreams) {
  194.       const groupId = getVideoGroupId(stream);
  195.       const validVideoStreams = validVideoStreamsMap.get(groupId) || [];
  196.       if (!validVideoStreams.length) {
  197.         validVideoStreams.push(stream);
  198.         validVideoIds.push(stream.id);
  199.       } else {
  200.         const previousStream = validVideoStreams[validVideoStreams.length - 1];
  201.         if (!isChangeTypeSupported) {
  202.           const previousCodec =
  203.             MimeUtils.getNormalizedCodec(previousStream.codecs);
  204.           const currentCodec =
  205.             MimeUtils.getNormalizedCodec(stream.codecs);
  206.           if (previousCodec !== currentCodec) {
  207.             continue;
  208.           }
  209.         }
  210.         const previousCodec =
  211.           MimeUtils.getNormalizedCodec(previousStream.codecs);
  212.         const currentCodec =
  213.           MimeUtils.getNormalizedCodec(stream.codecs);
  214.         if (previousCodec == currentCodec) {
  215.           if (!stream.bandwidth || !previousStream.bandwidth ||
  216.               stream.bandwidth > previousStream.bandwidth) {
  217.             validVideoStreams.push(stream);
  218.             validVideoIds.push(stream.id);
  219.           }
  220.         }
  221.       }
  222.       validVideoStreamsMap.set(groupId, validVideoStreams);
  223.     }
  225.     // Filter out any variants that don't match, forcing AbrManager to choose
  226.     // from a single video codec and a single audio codec possible.
  227.     manifest.variants = manifest.variants.filter((variant) => {
  228.       const audio = variant.audio;
  229.       const video = variant.video;
  230.       if (audio) {
  231.         if (!validAudioIds.includes(audio.id)) {
  232.           shaka.log.debug('Dropping Variant (better codec available)', variant);
  233.           return false;
  234.         }
  235.       }
  236.       if (video) {
  237.         if (!validVideoIds.includes(video.id)) {
  238.           shaka.log.debug('Dropping Variant (better codec available)', variant);
  239.           return false;
  240.         }
  241.       }
  242.       return true;
  243.     });
  244.   }
  246.   /**
  247.    * Choose the codecs by configured preferred audio and video codecs.
  248.    *
  249.    * @param {!Array<shaka.extern.Variant>} variants
  250.    * @param {!Array<string>} preferredVideoCodecs
  251.    * @param {!Array<string>} preferredAudioCodecs
  252.    * @return {!Array<shaka.extern.Variant>}
  253.    */
  254.   static choosePreferredCodecs(variants, preferredVideoCodecs,
  255.       preferredAudioCodecs) {
  256.     let subset = variants;
  257.     for (const videoCodec of preferredVideoCodecs) {
  258.       const filtered = subset.filter((variant) => {
  259.         return variant.video && variant.video.codecs.startsWith(videoCodec);
  260.       });
  261.       if (filtered.length) {
  262.         subset = filtered;
  263.         break;
  264.       }
  265.     }
  267.     for (const audioCodec of preferredAudioCodecs) {
  268.       const filtered = subset.filter((variant) => {
  269.         return variant.audio && variant.audio.codecs.startsWith(audioCodec);
  270.       });
  271.       if (filtered.length) {
  272.         subset = filtered;
  273.         break;
  274.       }
  275.     }
  276.     return subset;
  277.   }
  279.   /**
  280.    * Filter the variants in |manifest| to only include the variants that meet
  281.    * the given restrictions.
  282.    *
  283.    * @param {!shaka.extern.Manifest} manifest
  284.    * @param {shaka.extern.Restrictions} restrictions
  285.    * @param {shaka.extern.Resolution} maxHwResolution
  286.    */
  287.   static filterByRestrictions(manifest, restrictions, maxHwResolution) {
  288.     manifest.variants = manifest.variants.filter((variant) => {
  289.       return shaka.util.StreamUtils.meetsRestrictions(
  290.           variant, restrictions, maxHwResolution);
  291.     });
  292.   }
  294.   /**
  295.    * @param {shaka.extern.Variant} variant
  296.    * @param {shaka.extern.Restrictions} restrictions
  297.    *   Configured restrictions from the user.
  298.    * @param {shaka.extern.Resolution} maxHwRes
  299.    *   The maximum resolution the hardware can handle.
  300.    *   This is applied separately from user restrictions because the setting
  301.    *   should not be easily replaced by the user's configuration.
  302.    * @return {boolean}
  303.    * @export
  304.    */
  305.   static meetsRestrictions(variant, restrictions, maxHwRes) {
  306.     /** @type {function(number, number, number):boolean} */
  307.     const inRange = (x, min, max) => {
  308.       return x >= min && x <= max;
  309.     };
  311.     const video = variant.video;
  313.     // |video.width| and |video.height| can be undefined, which breaks
  314.     // the math, so make sure they are there first.
  315.     if (video && video.width && video.height) {
  316.       let videoWidth = video.width;
  317.       let videoHeight = video.height;
  318.       if (videoHeight > videoWidth) {
  319.         // Vertical video.
  320.         [videoWidth, videoHeight] = [videoHeight, videoWidth];
  321.       }
  323.       if (!inRange(videoWidth,
  324.           restrictions.minWidth,
  325.           Math.min(restrictions.maxWidth, maxHwRes.width))) {
  326.         return false;
  327.       }
  329.       if (!inRange(videoHeight,
  330.           restrictions.minHeight,
  331.           Math.min(restrictions.maxHeight, maxHwRes.height))) {
  332.         return false;
  333.       }
  335.       if (!inRange(video.width * video.height,
  336.           restrictions.minPixels,
  337.           restrictions.maxPixels)) {
  338.         return false;
  339.       }
  340.     }
  342.     // |variant.video.frameRate| can be undefined, which breaks
  343.     // the math, so make sure they are there first.
  344.     if (variant && variant.video && variant.video.frameRate) {
  345.       if (!inRange(variant.video.frameRate,
  346.           restrictions.minFrameRate,
  347.           restrictions.maxFrameRate)) {
  348.         return false;
  349.       }
  350.     }
  352.     // |variant.audio.channelsCount| can be undefined, which breaks
  353.     // the math, so make sure they are there first.
  354.     if (variant && variant.audio && variant.audio.channelsCount) {
  355.       if (!inRange(variant.audio.channelsCount,
  356.           restrictions.minChannelsCount,
  357.           restrictions.maxChannelsCount)) {
  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 {shaka.extern.Resolution} 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.drm.DrmEngine} drmEngine
  399.    * @param {shaka.extern.Manifest} manifest
  400.    * @param {!Array<string>=} preferredKeySystems
  401.    * @param {!Object<string, string>=} keySystemsMapping
  402.    */
  403.   static async filterManifest(drmEngine, manifest, preferredKeySystems = [],
  404.       keySystemsMapping = {}) {
  405.     await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
  406.         drmEngine, manifest, manifest.offlineSessionIds.length > 0,
  407.         preferredKeySystems, keySystemsMapping);
  408.     shaka.util.StreamUtils.filterTextStreams_(manifest);
  409.     await 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.drm.DrmEngine} drmEngine
  418.    * @param {shaka.extern.Manifest} manifest
  419.    * @param {boolean} usePersistentLicenses
  420.    * @param {!Array<string>} preferredKeySystems
  421.    * @param {!Object<string, string>} keySystemsMapping
  422.    */
  423.   static async filterManifestByMediaCapabilities(
  424.       drmEngine, manifest, usePersistentLicenses, preferredKeySystems,
  425.       keySystemsMapping) {
  426.     goog.asserts.assert(navigator.mediaCapabilities,
  427.         'MediaCapabilities should be valid.');
  429.     if (shaka.util.Platform.isXboxOne()) {
  430.       shaka.util.StreamUtils.overrideDolbyVisionCodecs(manifest.variants);
  431.     }
  432.     await shaka.util.StreamUtils.getDecodingInfosForVariants(
  433.         manifest.variants, usePersistentLicenses, /* srcEquals= */ false,
  434.         preferredKeySystems);
  436.     let keySystem = null;
  437.     if (drmEngine) {
  438.       const drmInfo = drmEngine.getDrmInfo();
  439.       if (drmInfo) {
  440.         keySystem = drmInfo.keySystem;
  441.       }
  442.     }
  444.     const StreamUtils = shaka.util.StreamUtils;
  446.     manifest.variants = manifest.variants.filter((variant) => {
  447.       const supported = StreamUtils.checkVariantSupported_(
  448.           variant, keySystem, keySystemsMapping);
  449.       // Filter out all unsupported variants.
  450.       if (!supported) {
  451.         shaka.log.debug('Dropping variant - not compatible with platform',
  452.             StreamUtils.getVariantSummaryString_(variant));
  453.       }
  454.       return supported;
  455.     });
  456.   }
  459.   /**
  460.    * Maps Dolby Vision codecs to H.264 and H.265 equivalents as a workaround
  461.    * to make Dolby Vision playback work on some platforms.
  462.    *
  463.    * Mapping is done according to the relevant Dolby documentation found here:
  464.    * https://professionalsupport.dolby.com/s/article/How-to-signal-Dolby-Vision-in-MPEG-DASH?language=en_US
  465.    * @param {!Array<!shaka.extern.Variant>} variants
  466.    */
  467.   static overrideDolbyVisionCodecs(variants) {
  468.     /** @type {!Map<string, string>} */
  469.     const codecMap = new Map()
  470.         .set('dvav', 'avc3')
  471.         .set('dva1', 'avc1')
  472.         .set('dvhe', 'hev1')
  473.         .set('dvh1', 'hvc1')
  474.         .set('dvc1', 'vvc1')
  475.         .set('dvi1', 'vvi1');
  477.     /** @type {!Set<!shaka.extern.Stream>} */
  478.     const streams = new Set();
  479.     for (const variant of variants) {
  480.       if (variant.video) {
  481.         streams.add(variant.video);
  482.       }
  483.     }
  484.     for (const video of streams) {
  485.       for (const [dvCodec, replacement] of codecMap) {
  486.         if (video.codecs.includes(dvCodec)) {
  487.           video.codecs = video.codecs.replace(dvCodec, replacement);
  488.           break;
  489.         }
  490.       }
  491.     }
  492.   }
  495.   /**
  496.    * @param {!shaka.extern.Variant} variant
  497.    * @param {?string} keySystem
  498.    * @param {!Object<string, string>} keySystemsMapping
  499.    * @return {boolean}
  500.    * @private
  501.    */
  502.   static checkVariantSupported_(variant, keySystem, keySystemsMapping) {
  503.     const variantSupported = variant.decodingInfos.some((decodingInfo) => {
  504.       if (!decodingInfo.supported) {
  505.         return false;
  506.       }
  507.       if (keySystem) {
  508.         const keySystemAccess = decodingInfo.keySystemAccess;
  509.         if (keySystemAccess) {
  510.           const currentKeySystem =
  511.               keySystemsMapping[keySystemAccess.keySystem] ||
  512.               keySystemAccess.keySystem;
  513.           if (currentKeySystem != keySystem) {
  514.             return false;
  515.           }
  516.         }
  517.       }
  518.       return true;
  519.     });
  520.     if (!variantSupported) {
  521.       return false;
  522.     }
  524.     const isXboxOne = shaka.util.Platform.isXboxOne();
  525.     const isFirefoxAndroid = shaka.util.Platform.isFirefox() &&
  526.         shaka.util.Platform.isAndroid();
  528.     // See: https://github.com/shaka-project/shaka-player/issues/3860
  529.     const video = variant.video;
  530.     const videoWidth = (video && video.width) || 0;
  531.     const videoHeight = (video && video.height) || 0;
  533.     // See: https://github.com/shaka-project/shaka-player/issues/3380
  534.     // Note: it makes sense to drop early
  535.     if (isXboxOne && video && (videoWidth > 1920 || videoHeight > 1080) &&
  536.         (video.codecs.includes('avc1.') || video.codecs.includes('avc3.'))) {
  537.       return false;
  538.     }
  540.     const videoDependencyStream = video && video.dependencyStream;
  541.     if (videoDependencyStream &&
  542.         !shaka.lcevc.Dec.isStreamSupported(videoDependencyStream)) {
  543.       return false;
  544.     }
  546.     const audio = variant.audio;
  548.     // See: https://github.com/shaka-project/shaka-player/issues/6111
  549.     // It seems that Firefox Android reports that it supports
  550.     // Opus + Widevine, but it is not actually supported.
  551.     // It makes sense to drop early.
  552.     if (isFirefoxAndroid && audio && audio.encrypted &&
  553.         audio.codecs.toLowerCase().includes('opus')) {
  554.       return false;
  555.     }
  557.     const audioDependencyStream = audio && audio.dependencyStream;
  558.     if (audioDependencyStream) {
  559.       return false;
  560.     }
  562.     return true;
  563.   }
  566.   /**
  567.    * Queries mediaCapabilities for the decoding info for that decoding config,
  568.    * and assigns it to the given variant.
  569.    * If that query has been done before, instead return a cached result.
  570.    * @param {!shaka.extern.Variant} variant
  571.    * @param {!Array<!MediaDecodingConfiguration>} decodingConfigs
  572.    * @private
  573.    */
  574.   static async getDecodingInfosForVariant_(variant, decodingConfigs) {
  575.     /**
  576.      * @param {?MediaCapabilitiesDecodingInfo} a
  577.      * @param {!MediaCapabilitiesDecodingInfo} b
  578.      * @return {!MediaCapabilitiesDecodingInfo}
  579.      */
  580.     const merge = (a, b) => {
  581.       if (!a) {
  582.         return b;
  583.       } else {
  584.         const res = shaka.util.ObjectUtils.shallowCloneObject(a);
  585.         res.supported = a.supported && b.supported;
  586.         res.powerEfficient = a.powerEfficient && b.powerEfficient;
  587.         res.smooth = a.smooth && b.smooth;
  588.         if (b.keySystemAccess && !res.keySystemAccess) {
  589.           res.keySystemAccess = b.keySystemAccess;
  590.         }
  591.         return res;
  592.       }
  593.     };
  595.     const StreamUtils = shaka.util.StreamUtils;
  596.     /** @type {?MediaCapabilitiesDecodingInfo} */
  597.     let finalResult = null;
  598.     const promises = [];
  599.     for (const decodingConfig of decodingConfigs) {
  600.       const cacheKey =
  601.           shaka.util.ObjectUtils.alphabeticalKeyOrderStringify(decodingConfig);
  603.       const cache = StreamUtils.decodingConfigCache_;
  604.       if (cache.has(cacheKey)) {
  605.         shaka.log.v2('Using cached results of mediaCapabilities.decodingInfo',
  606.             'for key', cacheKey);
  607.         finalResult = merge(finalResult, cache.get(cacheKey));
  608.       } else {
  609.         // Do a final pass-over of the decoding config: if a given stream has
  610.         // multiple codecs, that suggests that it switches between those codecs
  611.         // at points of the go-through.
  612.         // mediaCapabilities by itself will report "not supported" when you
  613.         // put in multiple different codecs, so each has to be checked
  614.         // individually. So check each and take the worst result, to determine
  615.         // overall variant compatibility.
  616.         promises.push(StreamUtils
  617.             .checkEachDecodingConfigCombination_(decodingConfig).then((res) => {
  618.               /** @type {?MediaCapabilitiesDecodingInfo} */
  619.               let acc = null;
  620.               for (const result of (res || [])) {
  621.                 acc = merge(acc, result);
  622.               }
  623.               if (acc) {
  624.                 cache.set(cacheKey, acc);
  625.                 finalResult = merge(finalResult, acc);
  626.               }
  627.             }));
  628.       }
  629.     }
  630.     await Promise.all(promises);
  631.     if (finalResult) {
  632.       variant.decodingInfos.push(finalResult);
  633.     }
  634.   }
  636.   /**
  637.    * @param {!MediaDecodingConfiguration} decodingConfig
  638.    * @return {!Promise<?Array<!MediaCapabilitiesDecodingInfo>>}
  639.    * @private
  640.    */
  641.   static checkEachDecodingConfigCombination_(decodingConfig) {
  642.     let videoCodecs = [''];
  643.     if (decodingConfig.video) {
  644.       videoCodecs = shaka.util.MimeUtils.getCodecs(
  645.           decodingConfig.video.contentType).split(',');
  646.     }
  647.     let audioCodecs = [''];
  648.     if (decodingConfig.audio) {
  649.       audioCodecs = shaka.util.MimeUtils.getCodecs(
  650.           decodingConfig.audio.contentType).split(',');
  651.     }
  652.     const promises = [];
  653.     for (const videoCodec of videoCodecs) {
  654.       for (const audioCodec of audioCodecs) {
  655.         const copy = shaka.util.ObjectUtils.cloneObject(decodingConfig);
  656.         if (decodingConfig.video) {
  657.           const mimeType = shaka.util.MimeUtils.getBasicType(
  658.               copy.video.contentType);
  659.           copy.video.contentType = shaka.util.MimeUtils.getFullType(
  660.               mimeType, videoCodec);
  661.         }
  662.         if (decodingConfig.audio) {
  663.           const mimeType = shaka.util.MimeUtils.getBasicType(
  664.               copy.audio.contentType);
  665.           copy.audio.contentType = shaka.util.MimeUtils.getFullType(
  666.               mimeType, audioCodec);
  667.         }
  668.         promises.push(new Promise((resolve, reject) => {
  669.           // On some (Android) WebView environments, decodingInfo will
  670.           // not resolve or reject, at least if RESOURCE_PROTECTED_MEDIA_ID
  671.           // is not set.  This is a workaround for that issue.
  672.           const TIMEOUT_FOR_DECODING_INFO_IN_SECONDS = 5;
  673.           let promise;
  674.           if (shaka.util.Platform.isAndroid()) {
  675.             promise = shaka.util.Functional.promiseWithTimeout(
  676.                 TIMEOUT_FOR_DECODING_INFO_IN_SECONDS,
  677.                 navigator.mediaCapabilities.decodingInfo(copy),
  678.             );
  679.           } else {
  680.             promise = navigator.mediaCapabilities.decodingInfo(copy);
  681.           }
  682.           promise.then((res) => {
  683.             resolve(res);
  684.           }).catch(reject);
  685.         }));
  686.       }
  687.     }
  688.     return Promise.all(promises).catch((e) => {
  689.       shaka.log.info('MediaCapabilities.decodingInfo() failed.',
  690.           JSON.stringify(decodingConfig), e);
  691.       return null;
  692.     });
  693.   }
  696.   /**
  697.    * Get the decodingInfo results of the variants via MediaCapabilities.
  698.    * This should be called after the DrmEngine is created and configured, and
  699.    * before DrmEngine sets the mediaKeys.
  700.    *
  701.    * @param {!Array<shaka.extern.Variant>} variants
  702.    * @param {boolean} usePersistentLicenses
  703.    * @param {boolean} srcEquals
  704.    * @param {!Array<string>} preferredKeySystems
  705.    * @exportDoc
  706.    */
  707.   static async getDecodingInfosForVariants(variants, usePersistentLicenses,
  708.       srcEquals, preferredKeySystems) {
  709.     const gotDecodingInfo = variants.some((variant) =>
  710.       variant.decodingInfos.length);
  711.     if (gotDecodingInfo) {
  712.       shaka.log.debug('Already got the variants\' decodingInfo.');
  713.       return;
  714.     }
  716.     // Try to get preferred key systems first to avoid unneeded calls to CDM.
  717.     for (const preferredKeySystem of preferredKeySystems) {
  718.       let keySystemSatisfied = false;
  719.       for (const variant of variants) {
  720.         /** @type {!Array<!Array<!MediaDecodingConfiguration>>} */
  721.         const decodingConfigs = shaka.util.StreamUtils.getDecodingConfigs_(
  722.             variant, usePersistentLicenses, srcEquals)
  723.             .filter((configs) => {
  724.               // All configs in a batch will have the same keySystem.
  725.               const config = configs[0];
  726.               const keySystem = config.keySystemConfiguration &&
  727.                 config.keySystemConfiguration.keySystem;
  728.               return keySystem === preferredKeySystem;
  729.             });
  731.         // The reason we are performing this await in a loop rather than
  732.         // batching into a `promise.all` is performance related.
  733.         // https://github.com/shaka-project/shaka-player/pull/4708#discussion_r1022581178
  734.         for (const configs of decodingConfigs) {
  735.           // eslint-disable-next-line no-await-in-loop
  736.           await shaka.util.StreamUtils.getDecodingInfosForVariant_(
  737.               variant, configs);
  738.         }
  739.         if (variant.decodingInfos.length) {
  740.           keySystemSatisfied = true;
  741.         }
  742.       } // for (const variant of variants)
  743.       if (keySystemSatisfied) {
  744.         // Return if any preferred key system is already satisfied.
  745.         return;
  746.       }
  747.     } // for (const preferredKeySystem of preferredKeySystems)
  749.     for (const variant of variants) {
  750.       /** @type {!Array<!Array<!MediaDecodingConfiguration>>} */
  751.       const decodingConfigs = shaka.util.StreamUtils.getDecodingConfigs_(
  752.           variant, usePersistentLicenses, srcEquals)
  753.           .filter((configs) => {
  754.             // All configs in a batch will have the same keySystem.
  755.             const config = configs[0];
  756.             const keySystem = config.keySystemConfiguration &&
  757.               config.keySystemConfiguration.keySystem;
  758.             // Avoid checking preferred systems twice.
  759.             return !keySystem || !preferredKeySystems.includes(keySystem);
  760.           });
  762.       // The reason we are performing this await in a loop rather than
  763.       // batching into a `promise.all` is performance related.
  764.       // https://github.com/shaka-project/shaka-player/pull/4708#discussion_r1022581178
  765.       for (const configs of decodingConfigs) {
  766.         // eslint-disable-next-line no-await-in-loop
  767.         await shaka.util.StreamUtils.getDecodingInfosForVariant_(
  768.             variant, configs);
  769.       }
  770.     }
  771.   }
  774.   /**
  775.    * Generate a batch of MediaDecodingConfiguration objects to get the
  776.    * decodingInfo results for each variant.
  777.    * Each batch shares the same DRM information, and represents the various
  778.    * fullMimeType combinations of the streams.
  779.    * @param {!shaka.extern.Variant} variant
  780.    * @param {boolean} usePersistentLicenses
  781.    * @param {boolean} srcEquals
  782.    * @return {!Array<!Array<!MediaDecodingConfiguration>>}
  783.    * @private
  784.    */
  785.   static getDecodingConfigs_(variant, usePersistentLicenses, srcEquals) {
  786.     const audio = variant.audio;
  787.     const video = variant.video;
  789.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  790.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  791.     const MimeUtils = shaka.util.MimeUtils;
  792.     const StreamUtils = shaka.util.StreamUtils;
  794.     const videoConfigs = [];
  795.     const audioConfigs = [];
  796.     if (video) {
  797.       for (const fullMimeType of video.fullMimeTypes) {
  798.         let videoCodecs = MimeUtils.getCodecs(fullMimeType);
  800.         // For multiplexed streams with audio+video codecs, the config should
  801.         // have AudioConfiguration and VideoConfiguration.
  802.         // We ignore the multiplexed audio when there is normal audio also.
  803.         if (videoCodecs.includes(',') && !audio) {
  804.           const allCodecs = videoCodecs.split(',');
  805.           const baseMimeType = MimeUtils.getBasicType(fullMimeType);
  807.           videoCodecs = ManifestParserUtils.guessCodecs(
  808.               ContentType.VIDEO, allCodecs);
  810.           let audioCodecs = ManifestParserUtils.guessCodecs(
  811.               ContentType.AUDIO, allCodecs);
  812.           audioCodecs = StreamUtils.getCorrectAudioCodecs(
  813.               audioCodecs, baseMimeType);
  815.           const audioFullType = MimeUtils.getFullOrConvertedType(
  816.               baseMimeType, audioCodecs, ContentType.AUDIO);
  818.           audioConfigs.push({
  819.             contentType: audioFullType,
  820.             channels: 2,
  821.             bitrate: variant.bandwidth || 1,
  822.             samplerate: 1,
  823.             spatialRendering: false,
  824.           });
  825.         }
  827.         videoCodecs = StreamUtils.getCorrectVideoCodecs(videoCodecs);
  828.         const fullType = MimeUtils.getFullOrConvertedType(
  829.             MimeUtils.getBasicType(fullMimeType), videoCodecs,
  830.             ContentType.VIDEO);
  832.         // VideoConfiguration
  833.         const videoConfig = {
  834.           contentType: fullType,
  836.           // NOTE: Some decoders strictly check the width and height fields and
  837.           // won't decode smaller than 64x64.  So if we don't have this info (as
  838.           // is the case in some of our simpler tests), assume a 64x64
  839.           // resolution to fill in this required field for MediaCapabilities.
  840.           //
  841.           // This became an issue specifically on Firefox on M1 Macs.
  842.           width: video.width || 64,
  843.           height: video.height || 64,
  845.           bitrate: video.bandwidth || variant.bandwidth || 1,
  846.           // framerate must be greater than 0, otherwise the config is invalid.
  847.           framerate: video.frameRate || 1,
  848.         };
  849.         if (video.hdr) {
  850.           switch (video.hdr) {
  851.             case 'SDR':
  852.               videoConfig.transferFunction = 'srgb';
  853.               break;
  854.             case 'PQ':
  855.               videoConfig.transferFunction = 'pq';
  856.               break;
  857.             case 'HLG':
  858.               videoConfig.transferFunction = 'hlg';
  859.               break;
  860.           }
  861.         }
  862.         if (video.colorGamut) {
  863.           videoConfig.colorGamut = video.colorGamut;
  864.         }
  865.         videoConfigs.push(videoConfig);
  866.       }
  867.     }
  868.     if (audio) {
  869.       for (const fullMimeType of audio.fullMimeTypes) {
  870.         const baseMimeType = MimeUtils.getBasicType(fullMimeType);
  871.         const codecs = StreamUtils.getCorrectAudioCodecs(
  872.             MimeUtils.getCodecs(fullMimeType), baseMimeType);
  873.         const fullType = MimeUtils.getFullOrConvertedType(
  874.             baseMimeType, codecs, ContentType.AUDIO);
  876.         // AudioConfiguration
  877.         audioConfigs.push({
  878.           contentType: fullType,
  879.           channels: audio.channelsCount || 2,
  880.           bitrate: audio.bandwidth || variant.bandwidth || 1,
  881.           samplerate: audio.audioSamplingRate || 1,
  882.           spatialRendering: audio.spatialAudio,
  883.         });
  884.       }
  885.     }
  887.     // Generate each combination of video and audio config as a separate
  888.     // MediaDecodingConfiguration, inside the main "batch".
  889.     /** @type {!Array<!MediaDecodingConfiguration>} */
  890.     const mediaDecodingConfigBatch = [];
  891.     if (videoConfigs.length == 0) {
  892.       videoConfigs.push(null);
  893.     }
  894.     if (audioConfigs.length == 0) {
  895.       audioConfigs.push(null);
  896.     }
  897.     for (const videoConfig of videoConfigs) {
  898.       for (const audioConfig of audioConfigs) {
  899.         /** @type {!MediaDecodingConfiguration} */
  900.         const mediaDecodingConfig = {
  901.           type: srcEquals ? 'file' : 'media-source',
  902.         };
  903.         if (videoConfig) {
  904.           mediaDecodingConfig.video = videoConfig;
  905.         }
  906.         if (audioConfig) {
  907.           mediaDecodingConfig.audio = audioConfig;
  908.         }
  909.         mediaDecodingConfigBatch.push(mediaDecodingConfig);
  910.       }
  911.     }
  913.     const videoDrmInfos = variant.video ? variant.video.drmInfos : [];
  914.     const audioDrmInfos = variant.audio ? variant.audio.drmInfos : [];
  915.     const allDrmInfos = videoDrmInfos.concat(audioDrmInfos);
  917.     // Return a list containing the mediaDecodingConfig for unencrypted variant.
  918.     if (!allDrmInfos.length) {
  919.       return [mediaDecodingConfigBatch];
  920.     }
  922.     // A list of MediaDecodingConfiguration objects created for the variant.
  923.     const configs = [];
  925.     // Get all the drm info so that we can avoid using nested loops when we
  926.     // just need the drm info.
  927.     const drmInfoByKeySystems = new Map();
  928.     for (const info of allDrmInfos) {
  929.       if (!drmInfoByKeySystems.get(info.keySystem)) {
  930.         drmInfoByKeySystems.set(info.keySystem, []);
  931.       }
  932.       drmInfoByKeySystems.get(info.keySystem).push(info);
  933.     }
  935.     const persistentState =
  936.         usePersistentLicenses ? 'required' : 'optional';
  937.     const sessionTypes =
  938.         usePersistentLicenses ? ['persistent-license'] : ['temporary'];
  940.     for (const keySystem of drmInfoByKeySystems.keys()) {
  941.       const drmInfos = drmInfoByKeySystems.get(keySystem);
  943.       // Get all the robustness info so that we can avoid using nested
  944.       // loops when we just need the robustness.
  945.       const drmInfosByRobustness = new Map();
  946.       for (const info of drmInfos) {
  947.         const keyName = `${info.videoRobustness},${info.audioRobustness}`;
  948.         if (!drmInfosByRobustness.get(keyName)) {
  949.           drmInfosByRobustness.set(keyName, []);
  950.         }
  951.         drmInfosByRobustness.get(keyName).push(info);
  952.       }
  954.       for (const drmInfosRobustness of drmInfosByRobustness.values()) {
  955.         const modifiedMediaDecodingConfigBatch = [];
  956.         for (const base of mediaDecodingConfigBatch) {
  957.           // Create a copy of the mediaDecodingConfig.
  958.           const config = /** @type {!MediaDecodingConfiguration} */
  959.               (Object.assign({}, base));
  962.           /** @type {!MediaCapabilitiesKeySystemConfiguration} */
  963.           const keySystemConfig = {
  964.             keySystem: keySystem,
  965.             initDataType: 'cenc',
  966.             persistentState: persistentState,
  967.             distinctiveIdentifier: 'optional',
  968.             sessionTypes: sessionTypes,
  969.           };
  971.           for (const info of drmInfosRobustness) {
  972.             if (info.initData && info.initData.length) {
  973.               const initDataTypes = new Set();
  974.               for (const initData of info.initData) {
  975.                 initDataTypes.add(initData.initDataType);
  976.               }
  977.               if (initDataTypes.size > 1) {
  978.                 shaka.log.v2('DrmInfo contains more than one initDataType,',
  979.                     'and we use the initDataType of the first initData.',
  980.                     info);
  981.               }
  982.               keySystemConfig.initDataType = info.initData[0].initDataType;
  983.             }
  985.             if (info.distinctiveIdentifierRequired) {
  986.               keySystemConfig.distinctiveIdentifier = 'required';
  987.             }
  988.             if (info.persistentStateRequired) {
  989.               keySystemConfig.persistentState = 'required';
  990.             }
  991.             if (info.sessionType) {
  992.               keySystemConfig.sessionTypes = [info.sessionType];
  993.             }
  995.             if (audio) {
  996.               if (!keySystemConfig.audio) {
  997.                 // KeySystemTrackConfiguration
  998.                 keySystemConfig.audio = {
  999.                   robustness: info.audioRobustness,
  1000.                 };
  1001.                 if (info.encryptionScheme) {
  1002.                   keySystemConfig.audio.encryptionScheme =
  1003.                       info.encryptionScheme;
  1004.                 }
  1005.               } else {
  1006.                 if (info.encryptionScheme) {
  1007.                   keySystemConfig.audio.encryptionScheme =
  1008.                       keySystemConfig.audio.encryptionScheme ||
  1009.                       info.encryptionScheme;
  1010.                 }
  1011.                 keySystemConfig.audio.robustness =
  1012.                     keySystemConfig.audio.robustness ||
  1013.                     info.audioRobustness;
  1014.               }
  1015.               // See: https://github.com/shaka-project/shaka-player/issues/4659
  1016.               if (keySystemConfig.audio.robustness == '') {
  1017.                 delete keySystemConfig.audio.robustness;
  1018.               }
  1019.             }
  1021.             if (video) {
  1022.               if (!keySystemConfig.video) {
  1023.                 // KeySystemTrackConfiguration
  1024.                 keySystemConfig.video = {
  1025.                   robustness: info.videoRobustness,
  1026.                 };
  1027.                 if (info.encryptionScheme) {
  1028.                   keySystemConfig.video.encryptionScheme =
  1029.                       info.encryptionScheme;
  1030.                 }
  1031.               } else {
  1032.                 if (info.encryptionScheme) {
  1033.                   keySystemConfig.video.encryptionScheme =
  1034.                       keySystemConfig.video.encryptionScheme ||
  1035.                       info.encryptionScheme;
  1036.                 }
  1037.                 keySystemConfig.video.robustness =
  1038.                     keySystemConfig.video.robustness ||
  1039.                     info.videoRobustness;
  1040.               }
  1041.               // See: https://github.com/shaka-project/shaka-player/issues/4659
  1042.               if (keySystemConfig.video.robustness == '') {
  1043.                 delete keySystemConfig.video.robustness;
  1044.               }
  1045.             }
  1046.           }
  1047.           config.keySystemConfiguration = keySystemConfig;
  1048.           modifiedMediaDecodingConfigBatch.push(config);
  1049.         }
  1050.         configs.push(modifiedMediaDecodingConfigBatch);
  1051.       }
  1052.     }
  1053.     return configs;
  1054.   }
  1057.   /**
  1058.    * Generates the correct audio codec for MediaDecodingConfiguration and
  1059.    * for MediaSource.isTypeSupported.
  1060.    * @param {string} codecs
  1061.    * @param {string} mimeType
  1062.    * @return {string}
  1063.    */
  1064.   static getCorrectAudioCodecs(codecs, mimeType) {
  1065.     // According to RFC 6381 section 3.3, 'fLaC' is actually the correct
  1066.     // codec string. We still need to map it to 'flac', as some browsers
  1067.     // currently don't support 'fLaC', while 'flac' is supported by most
  1068.     // major browsers.
  1069.     // See https://bugs.chromium.org/p/chromium/issues/detail?id=1422728
  1070.     if (codecs.toLowerCase() == 'flac') {
  1071.       if (!shaka.util.Platform.isApple()) {
  1072.         return 'flac';
  1073.       } else {
  1074.         return 'fLaC';
  1075.       }
  1076.     }
  1078.     // The same is true for 'Opus'.
  1079.     if (codecs.toLowerCase() === 'opus') {
  1080.       if (!shaka.util.Platform.isApple()) {
  1081.         return 'opus';
  1082.       } else {
  1083.         if (shaka.util.MimeUtils.getContainerType(mimeType) == 'mp4') {
  1084.           return 'Opus';
  1085.         } else {
  1086.           return 'opus';
  1087.         }
  1088.       }
  1089.     }
  1091.     if (codecs.toLowerCase() == 'ac-3' &&
  1092.         shaka.util.Platform.requiresEC3InitSegments()) {
  1093.       return 'ec-3';
  1094.     }
  1096.     return codecs;
  1097.   }
  1100.   /**
  1101.    * Generates the correct video codec for MediaDecodingConfiguration and
  1102.    * for MediaSource.isTypeSupported.
  1103.    * @param {string} codec
  1104.    * @return {string}
  1105.    */
  1106.   static getCorrectVideoCodecs(codec) {
  1107.     if (codec.includes('avc1')) {
  1108.       // Convert avc1 codec string from RFC-4281 to RFC-6381 for
  1109.       // MediaSource.isTypeSupported
  1110.       // Example, convert avc1.66.30 to avc1.42001e (0x42 == 66 and 0x1e == 30)
  1111.       const avcData = codec.split('.');
  1112.       if (avcData.length == 3) {
  1113.         let result = avcData.shift() + '.';
  1114.         result += parseInt(avcData.shift(), 10).toString(16);
  1115.         result +=
  1116.             ('000' + parseInt(avcData.shift(), 10).toString(16)).slice(-4);
  1117.         return result;
  1118.       }
  1119.     } else if (codec == 'vp9') {
  1120.       // MediaCapabilities supports 'vp09...' codecs, but not 'vp9'. Translate
  1121.       // vp9 codec strings into 'vp09...', to allow such content to play with
  1122.       // mediaCapabilities enabled.
  1123.       // This means profile 0, level 4.1, 8-bit color.  This supports 1080p @
  1124.       // 60Hz.  See https://en.wikipedia.org/wiki/VP9#Levels
  1125.       //
  1126.       // If we don't have more detailed codec info, assume this profile and
  1127.       // level because it's high enough to likely accommodate the parameters we
  1128.       // do have, such as width and height.  If an implementation is checking
  1129.       // the profile and level very strictly, we want older VP9 content to
  1130.       // still work to some degree.  But we don't want to set a level so high
  1131.       // that it is rejected by a hardware decoder that can't handle the
  1132.       // maximum requirements of the level.
  1133.       //
  1134.       // This became an issue specifically on Firefox on M1 Macs.
  1135.       return 'vp09.00.41.08';
  1136.     }
  1137.     return codec;
  1138.   }
  1141.   /**
  1142.    * Alters the given Manifest to filter out any streams incompatible with the
  1143.    * current variant.
  1144.    *
  1145.    * @param {?shaka.extern.Variant} currentVariant
  1146.    * @param {shaka.extern.Manifest} manifest
  1147.    */
  1148.   static filterManifestByCurrentVariant(currentVariant, manifest) {
  1149.     const StreamUtils = shaka.util.StreamUtils;
  1150.     manifest.variants = manifest.variants.filter((variant) => {
  1151.       const audio = variant.audio;
  1152.       const video = variant.video;
  1153.       if (audio && currentVariant && currentVariant.audio) {
  1154.         if (!StreamUtils.areStreamsCompatible_(audio, currentVariant.audio)) {
  1155.           shaka.log.debug('Dropping variant - not compatible with active audio',
  1156.               'active audio',
  1157.               StreamUtils.getStreamSummaryString_(currentVariant.audio),
  1158.               'variant.audio',
  1159.               StreamUtils.getStreamSummaryString_(audio));
  1160.           return false;
  1161.         }
  1162.       }
  1164.       if (video && currentVariant && currentVariant.video) {
  1165.         if (!StreamUtils.areStreamsCompatible_(video, currentVariant.video)) {
  1166.           shaka.log.debug('Dropping variant - not compatible with active video',
  1167.               'active video',
  1168.               StreamUtils.getStreamSummaryString_(currentVariant.video),
  1169.               'variant.video',
  1170.               StreamUtils.getStreamSummaryString_(video));
  1171.           return false;
  1172.         }
  1173.       }
  1175.       return true;
  1176.     });
  1177.   }
  1179.   /**
  1180.    * Alters the given Manifest to filter out any unsupported text streams.
  1181.    *
  1182.    * @param {shaka.extern.Manifest} manifest
  1183.    * @private
  1184.    */
  1185.   static filterTextStreams_(manifest) {
  1186.     // Filter text streams.
  1187.     manifest.textStreams = manifest.textStreams.filter((stream) => {
  1188.       const fullMimeType = shaka.util.MimeUtils.getFullType(
  1189.           stream.mimeType, stream.codecs);
  1190.       const keep = shaka.text.TextEngine.isTypeSupported(fullMimeType);
  1192.       if (!keep) {
  1193.         shaka.log.debug('Dropping text stream. Is not supported by the ' +
  1194.                         'platform.', stream);
  1195.       }
  1197.       return keep;
  1198.     });
  1199.   }
  1202.   /**
  1203.    * Alters the given Manifest to filter out any unsupported image streams.
  1204.    *
  1205.    * @param {shaka.extern.Manifest} manifest
  1206.    * @private
  1207.    */
  1208.   static async filterImageStreams_(manifest) {
  1209.     const imageStreams = [];
  1210.     for (const stream of manifest.imageStreams) {
  1211.       let mimeType = stream.mimeType;
  1212.       if (mimeType == 'application/mp4' && stream.codecs == 'mjpg') {
  1213.         mimeType = 'image/jpg';
  1214.       }
  1215.       if (!shaka.util.StreamUtils.supportedImageMimeTypes_.has(mimeType)) {
  1216.         const minImage = shaka.util.StreamUtils.minImage_.get(mimeType);
  1217.         if (minImage) {
  1218.           // eslint-disable-next-line no-await-in-loop
  1219.           const res = await shaka.util.StreamUtils.isImageSupported_(minImage);
  1220.           shaka.util.StreamUtils.supportedImageMimeTypes_.set(mimeType, res);
  1221.         } else {
  1222.           shaka.util.StreamUtils.supportedImageMimeTypes_.set(mimeType, false);
  1223.         }
  1224.       }
  1226.       const keep =
  1227.           shaka.util.StreamUtils.supportedImageMimeTypes_.get(mimeType);
  1229.       if (!keep) {
  1230.         shaka.log.debug('Dropping image stream. Is not supported by the ' +
  1231.                         'platform.', stream);
  1232.       } else {
  1233.         imageStreams.push(stream);
  1234.       }
  1235.     }
  1236.     manifest.imageStreams = imageStreams;
  1237.   }
  1239.   /**
  1240.    * @param {string} minImage
  1241.    * @return {!Promise<boolean>}
  1242.    * @private
  1243.    */
  1244.   static isImageSupported_(minImage) {
  1245.     return new Promise((resolve) => {
  1246.       const imageElement = /** @type {HTMLImageElement} */(new Image());
  1247.       imageElement.src = minImage;
  1248.       if ('decode' in imageElement) {
  1249.         imageElement.decode().then(() => {
  1250.           resolve(true);
  1251.         }).catch(() => {
  1252.           resolve(false);
  1253.         });
  1254.       } else {
  1255.         imageElement.onload = imageElement.onerror = () => {
  1256.           resolve(imageElement.height === 2);
  1257.         };
  1258.       }
  1259.     });
  1260.   }
  1262.   /**
  1263.    * @param {shaka.extern.Stream} s0
  1264.    * @param {shaka.extern.Stream} s1
  1265.    * @return {boolean}
  1266.    * @private
  1267.    */
  1268.   static areStreamsCompatible_(s0, s1) {
  1269.     // Basic mime types and basic codecs need to match.
  1270.     // For example, we can't adapt between WebM and MP4,
  1271.     // nor can we adapt between mp4a.* to ec-3.
  1272.     // We can switch between text types on the fly,
  1273.     // so don't run this check on text.
  1274.     if (s0.mimeType != s1.mimeType) {
  1275.       return false;
  1276.     }
  1278.     if (s0.codecs.split('.')[0] != s1.codecs.split('.')[0]) {
  1279.       return false;
  1280.     }
  1282.     return true;
  1283.   }
  1286.   /**
  1287.    * @param {shaka.extern.Variant} variant
  1288.    * @return {shaka.extern.Track}
  1289.    */
  1290.   static variantToTrack(variant) {
  1291.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  1292.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1294.     /** @type {?shaka.extern.Stream} */
  1295.     const audio = variant.audio;
  1296.     /** @type {?shaka.extern.Stream} */
  1297.     const video = variant.video;
  1299.     /** @type {?string} */
  1300.     const audioMimeType = audio ? audio.mimeType : null;
  1301.     /** @type {?string} */
  1302.     const videoMimeType = video ? video.mimeType : null;
  1304.     /** @type {?string} */
  1305.     const audioCodec = audio ? audio.codecs : null;
  1306.     /** @type {?string} */
  1307.     const videoCodec = video ? video.codecs : null;
  1309.     /** @type {?string} */
  1310.     const audioGroupId = audio ? audio.groupId : null;
  1312.     /** @type {!Array<string>} */
  1313.     const mimeTypes = [];
  1314.     if (video) {
  1315.       mimeTypes.push(video.mimeType);
  1316.     }
  1317.     if (audio) {
  1318.       mimeTypes.push(audio.mimeType);
  1319.     }
  1320.     /** @type {?string} */
  1321.     const mimeType = mimeTypes[0] || null;
  1323.     /** @type {!Array<string>} */
  1324.     const kinds = [];
  1325.     if (audio) {
  1326.       kinds.push(audio.kind);
  1327.     }
  1328.     if (video) {
  1329.       kinds.push(video.kind);
  1330.     }
  1331.     /** @type {?string} */
  1332.     const kind = kinds[0] || null;
  1334.     /** @type {!Set<string>} */
  1335.     const roles = new Set();
  1336.     if (audio) {
  1337.       for (const role of audio.roles) {
  1338.         roles.add(role);
  1339.       }
  1340.     }
  1341.     if (video) {
  1342.       for (const role of video.roles) {
  1343.         roles.add(role);
  1344.       }
  1345.     }
  1347.     /** @type {shaka.extern.Track} */
  1348.     const track = {
  1349.       id: variant.id,
  1350.       active: false,
  1351.       type: 'variant',
  1352.       bandwidth: variant.bandwidth,
  1353.       language: variant.language,
  1354.       label: null,
  1355.       kind: kind,
  1356.       width: null,
  1357.       height: null,
  1358.       frameRate: null,
  1359.       pixelAspectRatio: null,
  1360.       hdr: null,
  1361.       colorGamut: null,
  1362.       videoLayout: null,
  1363.       mimeType: mimeType,
  1364.       audioMimeType: audioMimeType,
  1365.       videoMimeType: videoMimeType,
  1366.       codecs: '',
  1367.       audioCodec: audioCodec,
  1368.       videoCodec: videoCodec,
  1369.       primary: variant.primary,
  1370.       roles: Array.from(roles),
  1371.       audioRoles: null,
  1372.       forced: false,
  1373.       videoId: null,
  1374.       audioId: null,
  1375.       audioGroupId: audioGroupId,
  1376.       channelsCount: null,
  1377.       audioSamplingRate: null,
  1378.       spatialAudio: false,
  1379.       tilesLayout: null,
  1380.       audioBandwidth: null,
  1381.       videoBandwidth: null,
  1382.       originalVideoId: null,
  1383.       originalAudioId: null,
  1384.       originalTextId: null,
  1385.       originalImageId: null,
  1386.       accessibilityPurpose: null,
  1387.       originalLanguage: null,
  1388.     };
  1390.     if (video) {
  1391.       track.videoId = video.id;
  1392.       track.originalVideoId = video.originalId;
  1393.       track.width = video.width || null;
  1394.       track.height = video.height || null;
  1395.       track.frameRate = video.frameRate || null;
  1396.       track.pixelAspectRatio = video.pixelAspectRatio || null;
  1397.       track.videoBandwidth = video.bandwidth || null;
  1398.       track.hdr = video.hdr || null;
  1399.       track.colorGamut = video.colorGamut || null;
  1400.       track.videoLayout = video.videoLayout || null;
  1402.       const dependencyStream = video.dependencyStream;
  1403.       if (dependencyStream) {
  1404.         track.width = dependencyStream.width || track.width;
  1405.         track.height = dependencyStream.height || track.height;
  1406.         track.videoCodec = dependencyStream.codecs || track.videoCodec;
  1407.       }
  1409.       if (videoCodec.includes(',')) {
  1410.         track.channelsCount = video.channelsCount;
  1411.         track.audioSamplingRate = video.audioSamplingRate;
  1412.         track.spatialAudio = video.spatialAudio;
  1413.         track.originalLanguage = video.originalLanguage;
  1414.         track.audioMimeType = videoMimeType;
  1415.         const allCodecs = videoCodec.split(',');
  1416.         try {
  1417.           track.videoCodec = ManifestParserUtils.guessCodecs(
  1418.               ContentType.VIDEO, allCodecs);
  1419.           track.audioCodec = ManifestParserUtils.guessCodecs(
  1420.               ContentType.AUDIO, allCodecs);
  1421.         } catch (e) {
  1422.           // Ignore this error.
  1423.         }
  1424.       }
  1425.     }
  1427.     if (audio) {
  1428.       track.audioId = audio.id;
  1429.       track.originalAudioId = audio.originalId;
  1430.       track.channelsCount = audio.channelsCount;
  1431.       track.audioSamplingRate = audio.audioSamplingRate;
  1432.       track.audioBandwidth = audio.bandwidth || null;
  1433.       track.spatialAudio = audio.spatialAudio;
  1434.       track.label = audio.label;
  1435.       track.audioRoles = audio.roles;
  1436.       track.accessibilityPurpose = audio.accessibilityPurpose;
  1437.       track.originalLanguage = audio.originalLanguage;
  1439.       const dependencyStream = audio.dependencyStream;
  1440.       if (dependencyStream) {
  1441.         track.audioCodec = dependencyStream.codecs || track.audioCodec;
  1442.       }
  1443.     }
  1445.     /** @type {!Array<string>} */
  1446.     const codecs = [];
  1447.     if (track.videoCodec) {
  1448.       codecs.push(track.videoCodec);
  1449.     }
  1450.     if (track.audioCodec) {
  1451.       codecs.push(track.audioCodec);
  1452.     }
  1453.     track.codecs = codecs.join(', ');
  1455.     return track;
  1456.   }
  1459.   /**
  1460.    * @param {shaka.extern.Stream} stream
  1461.    * @return {shaka.extern.Track}
  1462.    */
  1463.   static textStreamToTrack(stream) {
  1464.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1466.     /** @type {shaka.extern.Track} */
  1467.     const track = {
  1468.       id: stream.id,
  1469.       active: false,
  1470.       type: ContentType.TEXT,
  1471.       bandwidth: 0,
  1472.       language: stream.language,
  1473.       label: stream.label,
  1474.       kind: stream.kind || null,
  1475.       width: null,
  1476.       height: null,
  1477.       frameRate: null,
  1478.       pixelAspectRatio: null,
  1479.       hdr: null,
  1480.       colorGamut: null,
  1481.       videoLayout: null,
  1482.       mimeType: stream.mimeType,
  1483.       audioMimeType: null,
  1484.       videoMimeType: null,
  1485.       codecs: stream.codecs || null,
  1486.       audioCodec: null,
  1487.       videoCodec: null,
  1488.       primary: stream.primary,
  1489.       roles: stream.roles,
  1490.       audioRoles: null,
  1491.       forced: stream.forced,
  1492.       videoId: null,
  1493.       audioId: null,
  1494.       audioGroupId: null,
  1495.       channelsCount: null,
  1496.       audioSamplingRate: null,
  1497.       spatialAudio: false,
  1498.       tilesLayout: null,
  1499.       audioBandwidth: null,
  1500.       videoBandwidth: null,
  1501.       originalVideoId: null,
  1502.       originalAudioId: null,
  1503.       originalTextId: stream.originalId,
  1504.       originalImageId: null,
  1505.       accessibilityPurpose: stream.accessibilityPurpose,
  1506.       originalLanguage: stream.originalLanguage,
  1507.     };
  1509.     return track;
  1510.   }
  1513.   /**
  1514.    * @param {shaka.extern.Stream} stream
  1515.    * @return {shaka.extern.Track}
  1516.    */
  1517.   static imageStreamToTrack(stream) {
  1518.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1520.     let width = stream.width || null;
  1521.     let height = stream.height || null;
  1523.     // The stream width and height represent the size of the entire thumbnail
  1524.     // sheet, so divide by the layout.
  1525.     let reference = null;
  1526.     // Note: segmentIndex is built by default for HLS, but not for DASH, but
  1527.     // in DASH this information comes at the stream level and not at the
  1528.     // segment level.
  1529.     if (stream.segmentIndex) {
  1530.       reference = stream.segmentIndex.earliestReference();
  1531.     }
  1532.     let layout = stream.tilesLayout;
  1533.     if (reference) {
  1534.       layout = reference.getTilesLayout() || layout;
  1535.     }
  1536.     if (layout && width != null) {
  1537.       width /= Number(layout.split('x')[0]);
  1538.     }
  1539.     if (layout && height != null) {
  1540.       height /= Number(layout.split('x')[1]);
  1541.     }
  1542.     // TODO: What happens if there are multiple grids, with different
  1543.     // layout sizes, inside this image stream?
  1545.     /** @type {shaka.extern.Track} */
  1546.     const track = {
  1547.       id: stream.id,
  1548.       active: false,
  1549.       type: ContentType.IMAGE,
  1550.       bandwidth: stream.bandwidth || 0,
  1551.       language: '',
  1552.       label: null,
  1553.       kind: null,
  1554.       width,
  1555.       height,
  1556.       frameRate: null,
  1557.       pixelAspectRatio: null,
  1558.       hdr: null,
  1559.       colorGamut: null,
  1560.       videoLayout: null,
  1561.       mimeType: stream.mimeType,
  1562.       audioMimeType: null,
  1563.       videoMimeType: null,
  1564.       codecs: stream.codecs || null,
  1565.       audioCodec: null,
  1566.       videoCodec: null,
  1567.       primary: false,
  1568.       roles: [],
  1569.       audioRoles: null,
  1570.       forced: false,
  1571.       videoId: null,
  1572.       audioId: null,
  1573.       audioGroupId: null,
  1574.       channelsCount: null,
  1575.       audioSamplingRate: null,
  1576.       spatialAudio: false,
  1577.       tilesLayout: layout || null,
  1578.       audioBandwidth: null,
  1579.       videoBandwidth: null,
  1580.       originalVideoId: null,
  1581.       originalAudioId: null,
  1582.       originalTextId: null,
  1583.       originalImageId: stream.originalId,
  1584.       accessibilityPurpose: null,
  1585.       originalLanguage: null,
  1586.     };
  1588.     return track;
  1589.   }
  1592.   /**
  1593.    * Generate and return an ID for this track, since the ID field is optional.
  1594.    *
  1595.    * @param {TextTrack|AudioTrack} html5Track
  1596.    * @return {number} The generated ID.
  1597.    */
  1598.   static html5TrackId(html5Track) {
  1599.     if (!html5Track['__shaka_id']) {
  1600.       html5Track['__shaka_id'] = shaka.util.StreamUtils.nextTrackId_++;
  1601.     }
  1602.     return html5Track['__shaka_id'];
  1603.   }
  1606.   /**
  1607.    * @param {TextTrack} textTrack
  1608.    * @return {shaka.extern.Track}
  1609.    */
  1610.   static html5TextTrackToTrack(textTrack) {
  1611.     const StreamUtils = shaka.util.StreamUtils;
  1613.     /** @type {shaka.extern.Track} */
  1614.     const track = StreamUtils.html5TrackToGenericShakaTrack_(textTrack);
  1615.     track.active = textTrack.mode != 'disabled';
  1616.     track.type = 'text';
  1617.     track.originalTextId = textTrack.id;
  1618.     if (textTrack.kind == 'captions') {
  1619.       // See: https://github.com/shaka-project/shaka-player/issues/6233
  1620.       track.mimeType = 'unknown';
  1621.     }
  1622.     if (textTrack.kind == 'subtitles') {
  1623.       track.mimeType = 'text/vtt';
  1624.     }
  1625.     if (textTrack.kind) {
  1626.       track.roles = [textTrack.kind];
  1627.     }
  1628.     if (textTrack.kind == 'forced') {
  1629.       track.forced = true;
  1630.     }
  1632.     return track;
  1633.   }
  1636.   /**
  1637.    * @param {AudioTrack} audioTrack
  1638.    * @return {shaka.extern.Track}
  1639.    */
  1640.   static html5AudioTrackToTrack(audioTrack) {
  1641.     const StreamUtils = shaka.util.StreamUtils;
  1643.     /** @type {shaka.extern.Track} */
  1644.     const track = StreamUtils.html5TrackToGenericShakaTrack_(audioTrack);
  1645.     track.active = audioTrack.enabled;
  1646.     track.type = 'variant';
  1647.     track.originalAudioId = audioTrack.id;
  1649.     if (audioTrack.kind == 'main') {
  1650.       track.primary = true;
  1651.     }
  1652.     if (audioTrack.kind) {
  1653.       track.roles = [audioTrack.kind];
  1654.       track.audioRoles = [audioTrack.kind];
  1655.       track.label = audioTrack.label;
  1656.     }
  1658.     return track;
  1659.   }
  1662.   /**
  1663.    * Creates a Track object with non-type specific fields filled out.  The
  1664.    * caller is responsible for completing the Track object with any
  1665.    * type-specific information (audio or text).
  1666.    *
  1667.    * @param {TextTrack|AudioTrack} html5Track
  1668.    * @return {shaka.extern.Track}
  1669.    * @private
  1670.    */
  1671.   static html5TrackToGenericShakaTrack_(html5Track) {
  1672.     const language = html5Track.language;
  1674.     /** @type {shaka.extern.Track} */
  1675.     const track = {
  1676.       id: shaka.util.StreamUtils.html5TrackId(html5Track),
  1677.       active: false,
  1678.       type: '',
  1679.       bandwidth: 0,
  1680.       language: shaka.util.LanguageUtils.normalize(language || 'und'),
  1681.       label: html5Track.label,
  1682.       kind: html5Track.kind,
  1683.       width: null,
  1684.       height: null,
  1685.       frameRate: null,
  1686.       pixelAspectRatio: null,
  1687.       hdr: null,
  1688.       colorGamut: null,
  1689.       videoLayout: null,
  1690.       mimeType: null,
  1691.       audioMimeType: null,
  1692.       videoMimeType: null,
  1693.       codecs: null,
  1694.       audioCodec: null,
  1695.       videoCodec: null,
  1696.       primary: false,
  1697.       roles: [],
  1698.       forced: false,
  1699.       audioRoles: null,
  1700.       videoId: null,
  1701.       audioId: null,
  1702.       audioGroupId: null,
  1703.       channelsCount: null,
  1704.       audioSamplingRate: null,
  1705.       spatialAudio: false,
  1706.       tilesLayout: null,
  1707.       audioBandwidth: null,
  1708.       videoBandwidth: null,
  1709.       originalVideoId: null,
  1710.       originalAudioId: null,
  1711.       originalTextId: null,
  1712.       originalImageId: null,
  1713.       accessibilityPurpose: null,
  1714.       originalLanguage: language,
  1715.     };
  1717.     return track;
  1718.   }
  1721.   /**
  1722.    * Determines if the given variant is playable.
  1723.    * @param {!shaka.extern.Variant} variant
  1724.    * @return {boolean}
  1725.    */
  1726.   static isPlayable(variant) {
  1727.     return variant.allowedByApplication &&
  1728.         variant.allowedByKeySystem &&
  1729.         variant.disabledUntilTime == 0;
  1730.   }
  1733.   /**
  1734.    * Filters out unplayable variants.
  1735.    * @param {!Array<!shaka.extern.Variant>} variants
  1736.    * @return {!Array<!shaka.extern.Variant>}
  1737.    */
  1738.   static getPlayableVariants(variants) {
  1739.     return variants.filter((variant) => {
  1740.       return shaka.util.StreamUtils.isPlayable(variant);
  1741.     });
  1742.   }
  1745.   /**
  1746.    * Chooses streams according to the given config.
  1747.    * Works both for Stream and Track types due to their similarities.
  1748.    *
  1749.    * @param {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>} streams
  1750.    * @param {string} preferredLanguage
  1751.    * @param {string} preferredRole
  1752.    * @param {boolean} preferredForced
  1753.    * @return {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>}
  1754.    */
  1755.   static filterStreamsByLanguageAndRole(
  1756.       streams, preferredLanguage, preferredRole, preferredForced) {
  1757.     const LanguageUtils = shaka.util.LanguageUtils;
  1759.     /** @type {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>} */
  1760.     let chosen = streams;
  1762.     // Start with the set of primary streams.
  1763.     /** @type {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>} */
  1764.     const primary = streams.filter((stream) => {
  1765.       return stream.primary;
  1766.     });
  1768.     if (primary.length) {
  1769.       chosen = primary;
  1770.     }
  1772.     // Now reduce the set to one language.  This covers both arbitrary language
  1773.     // choice and the reduction of the "primary" stream set to one language.
  1774.     const firstLanguage = chosen.length ? chosen[0].language : '';
  1775.     chosen = chosen.filter((stream) => {
  1776.       return stream.language == firstLanguage;
  1777.     });
  1779.     // Find the streams that best match our language preference. This will
  1780.     // override previous selections.
  1781.     if (preferredLanguage) {
  1782.       const closestLocale = LanguageUtils.findClosestLocale(
  1783.           LanguageUtils.normalize(preferredLanguage),
  1784.           streams.map((stream) => stream.language));
  1786.       // Only replace |chosen| if we found a locale that is close to our
  1787.       // preference.
  1788.       if (closestLocale) {
  1789.         chosen = streams.filter((stream) => {
  1790.           const locale = LanguageUtils.normalize(stream.language);
  1791.           return locale == closestLocale;
  1792.         });
  1793.       }
  1794.     }
  1796.     // Filter by forced preference
  1797.     chosen = chosen.filter((stream) => {
  1798.       return stream.forced == preferredForced;
  1799.     });
  1801.     // Now refine the choice based on role preference.
  1802.     if (preferredRole) {
  1803.       const roleMatches = shaka.util.StreamUtils.filterStreamsByRole_(
  1804.           chosen, preferredRole);
  1805.       if (roleMatches.length) {
  1806.         return roleMatches;
  1807.       } else {
  1808.         shaka.log.warning('No exact match for the text role could be found.');
  1809.       }
  1810.     } else {
  1811.       // Prefer text streams with no roles, if they exist.
  1812.       const noRoleMatches = chosen.filter((stream) => {
  1813.         return stream.roles.length == 0;
  1814.       });
  1815.       if (noRoleMatches.length) {
  1816.         return noRoleMatches;
  1817.       }
  1818.     }
  1820.     // Either there was no role preference, or it could not be satisfied.
  1821.     // Choose an arbitrary role, if there are any, and filter out any other
  1822.     // roles. This ensures we never adapt between roles.
  1824.     const allRoles = chosen.map((stream) => {
  1825.       return stream.roles;
  1826.     }).reduce(shaka.util.Functional.collapseArrays, []);
  1828.     if (!allRoles.length) {
  1829.       return chosen;
  1830.     }
  1831.     return shaka.util.StreamUtils.filterStreamsByRole_(chosen, allRoles[0]);
  1832.   }
  1835.   /**
  1836.    * Filter Streams by role.
  1837.    * Works both for Stream and Track types due to their similarities.
  1838.    *
  1839.    * @param {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>} streams
  1840.    * @param {string} preferredRole
  1841.    * @return {!Array<!shaka.extern.Stream>|!Array<!shaka.extern.Track>}
  1842.    * @private
  1843.    */
  1844.   static filterStreamsByRole_(streams, preferredRole) {
  1845.     return streams.filter((stream) => {
  1846.       return stream.roles.includes(preferredRole);
  1847.     });
  1848.   }
  1851.   /**
  1852.    * Checks if the given stream is an audio stream.
  1853.    *
  1854.    * @param {shaka.extern.Stream} stream
  1855.    * @return {boolean}
  1856.    */
  1857.   static isAudio(stream) {
  1858.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1859.     return stream.type == ContentType.AUDIO;
  1860.   }
  1863.   /**
  1864.    * Checks if the given stream is a video stream.
  1865.    *
  1866.    * @param {shaka.extern.Stream} stream
  1867.    * @return {boolean}
  1868.    */
  1869.   static isVideo(stream) {
  1870.     const ContentType = shaka.util.ManifestParserUtils.ContentType;
  1871.     return stream.type == ContentType.VIDEO;
  1872.   }
  1875.   /**
  1876.    * Get all non-null streams in the variant as an array.
  1877.    *
  1878.    * @param {shaka.extern.Variant} variant
  1879.    * @return {!Array<shaka.extern.Stream>}
  1880.    */
  1881.   static getVariantStreams(variant) {
  1882.     const streams = [];
  1884.     if (variant.audio) {
  1885.       streams.push(variant.audio);
  1886.     }
  1887.     if (variant.video) {
  1888.       streams.push(variant.video);
  1889.     }
  1891.     return streams;
  1892.   }
  1895.   /**
  1896.    * Indicates if some of the variant's streams are fastSwitching.
  1897.    *
  1898.    * @param {shaka.extern.Variant} variant
  1899.    * @return {boolean}
  1900.    */
  1901.   static isFastSwitching(variant) {
  1902.     if (variant.audio && variant.audio.fastSwitching) {
  1903.       return true;
  1904.     }
  1905.     if (variant.video && variant.video.fastSwitching) {
  1906.       return true;
  1907.     }
  1908.     return false;
  1909.   }
  1912.   /**
  1913.    * Set the best iframe stream to the original stream.
  1914.    *
  1915.    * @param {!shaka.extern.Stream} stream
  1916.    * @param {!Array<!shaka.extern.Stream>} iFrameStreams
  1917.    */
  1918.   static setBetterIFrameStream(stream, iFrameStreams) {
  1919.     if (!iFrameStreams.length) {
  1920.       return;
  1921.     }
  1922.     const validStreams = iFrameStreams.filter((iFrameStream) =>
  1923.       shaka.util.MimeUtils.getNormalizedCodec(stream.codecs) ==
  1924.       shaka.util.MimeUtils.getNormalizedCodec(iFrameStream.codecs))
  1925.         .sort((a, b) => {
  1926.           if (!a.bandwidth || !b.bandwidth || a.bandwidth == b.bandwidth) {
  1927.             return (a.width || 0) - (b.width || 0);
  1928.           }
  1929.           return a.bandwidth - b.bandwidth;
  1930.         });
  1931.     stream.trickModeVideo = validStreams[0];
  1932.     if (validStreams.length > 1) {
  1933.       const sameResolutionStream = validStreams.find((iFrameStream) =>
  1934.         stream.width == iFrameStream.width &&
  1935.         stream.height == iFrameStream.height);
  1936.       if (sameResolutionStream) {
  1937.         stream.trickModeVideo = sameResolutionStream;
  1938.       }
  1939.     }
  1940.   }
  1943.   /**
  1944.    * Returns a string of a variant, with the attribute values of its audio
  1945.    * and/or video streams for log printing.
  1946.    * @param {shaka.extern.Variant} variant
  1947.    * @return {string}
  1948.    * @private
  1949.    */
  1950.   static getVariantSummaryString_(variant) {
  1951.     const summaries = [];
  1952.     if (variant.audio) {
  1953.       summaries.push(shaka.util.StreamUtils.getStreamSummaryString_(
  1954.           variant.audio));
  1955.     }
  1956.     if (variant.video) {
  1957.       summaries.push(shaka.util.StreamUtils.getStreamSummaryString_(
  1958.           variant.video));
  1959.     }
  1960.     return summaries.join(', ');
  1961.   }
  1963.   /**
  1964.    * Returns a string of an audio or video stream for log printing.
  1965.    * @param {shaka.extern.Stream} stream
  1966.    * @return {string}
  1967.    * @private
  1968.    */
  1969.   static getStreamSummaryString_(stream) {
  1970.     // Accepted parameters for Chromecast can be found (internally) at
  1971.     // go/cast-mime-params
  1973.     if (shaka.util.StreamUtils.isAudio(stream)) {
  1974.       return 'type=audio' +
  1975.              ' codecs=' + stream.codecs +
  1976.              ' bandwidth='+ stream.bandwidth +
  1977.              ' channelsCount=' + stream.channelsCount +
  1978.              ' audioSamplingRate=' + stream.audioSamplingRate;
  1979.     }
  1981.     if (shaka.util.StreamUtils.isVideo(stream)) {
  1982.       return 'type=video' +
  1983.              ' codecs=' + stream.codecs +
  1984.              ' bandwidth=' + stream.bandwidth +
  1985.              ' frameRate=' + stream.frameRate +
  1986.              ' width=' + stream.width +
  1987.              ' height=' + stream.height;
  1988.     }
  1990.     return 'unexpected stream type';
  1991.   }
  1994.   /**
  1995.    * Clears underlying decoding config cache.
  1996.    */
  1997.   static clearDecodingConfigCache() {
  1998.     shaka.util.StreamUtils.decodingConfigCache_.clear();
  1999.   }
  2002.   /**
  2003.    * Check if we should show text on screen automatically.
  2004.    *
  2005.    * @param {?shaka.extern.Stream} audioStream
  2006.    * @param {shaka.extern.Stream} textStream
  2007.    * @param {!shaka.extern.PlayerConfiguration} config
  2008.    * @return {boolean}
  2009.    */
  2010.   static shouldInitiallyShowText(audioStream, textStream, config) {
  2011.     const AutoShowText = shaka.config.AutoShowText;
  2013.     if (config.autoShowText == AutoShowText.NEVER) {
  2014.       return false;
  2015.     }
  2016.     if (config.autoShowText == AutoShowText.ALWAYS) {
  2017.       return true;
  2018.     }
  2020.     const LanguageUtils = shaka.util.LanguageUtils;
  2022.     /** @type {string} */
  2023.     const preferredTextLocale =
  2024.         LanguageUtils.normalize(config.preferredTextLanguage);
  2025.     /** @type {string} */
  2026.     const textLocale = LanguageUtils.normalize(textStream.language);
  2028.     if (config.autoShowText == AutoShowText.IF_PREFERRED_TEXT_LANGUAGE) {
  2029.       // Only the text language match matters.
  2030.       return LanguageUtils.areLanguageCompatible(
  2031.           textLocale,
  2032.           preferredTextLocale);
  2033.     }
  2035.     if (config.autoShowText == AutoShowText.IF_SUBTITLES_MAY_BE_NEEDED) {
  2036.       if (!audioStream) {
  2037.         return false;
  2038.       }
  2039.       /* The text should automatically be shown if the text is
  2040.        * language-compatible with the user's text language preference, but not
  2041.        * compatible with the audio.  These are cases where we deduce that
  2042.        * subtitles may be needed.
  2043.        *
  2044.        * For example:
  2045.        *   preferred | chosen | chosen |
  2046.        *   text      | text   | audio  | show
  2047.        *   -----------------------------------
  2048.        *   en-CA     | en     | jp     | true
  2049.        *   en        | en-US  | fr     | true
  2050.        *   fr-CA     | en-US  | jp     | false
  2051.        *   en-CA     | en-US  | en-US  | false
  2052.        *
  2053.        */
  2054.       /** @type {string} */
  2055.       const audioLocale = LanguageUtils.normalize(audioStream.language);
  2057.       return (
  2058.         LanguageUtils.areLanguageCompatible(textLocale, preferredTextLocale) &&
  2059.         !LanguageUtils.areLanguageCompatible(audioLocale, textLocale));
  2060.     }
  2062.     shaka.log.alwaysWarn('Invalid autoShowText setting!');
  2063.     return false;
  2064.   }
  2065. };
  2068. /**
  2069.  * A cache of results from mediaCapabilities.decodingInfo, indexed by the
  2070.  * (stringified) decodingConfig.
  2071.  *
  2072.  * @type {Map<string, !MediaCapabilitiesDecodingInfo>}
  2073.  * @private
  2074.  */
  2075. shaka.util.StreamUtils.decodingConfigCache_ = new Map();
  2078. /** @private {number} */
  2079. shaka.util.StreamUtils.nextTrackId_ = 0;
  2081. /**
  2082.  * @enum {string}
  2083.  */
  2084. shaka.util.StreamUtils.DecodingAttributes = {
  2085.   SMOOTH: 'smooth',
  2086.   POWER: 'powerEfficient',
  2087. };
  2089. /**
  2090.  * @private {!Map<string, boolean>}
  2091.  */
  2092. shaka.util.StreamUtils.supportedImageMimeTypes_ = new Map()
  2093.     .set('image/svg+xml', true)
  2094.     .set('image/png', true)
  2095.     .set('image/jpeg', true)
  2096.     .set('image/jpg', true);
  2098. /**
  2099.  * @const {string}
  2100.  * @private
  2101.  */
  2102. // cspell: disable-next-line
  2103. shaka.util.StreamUtils.minWebPImage_ = 'data:image/webp;base64,UklGRjoAAABXRU' +
  2104.     'JQVlA4IC4AAACyAgCdASoCAAIALmk0mk0iIiIiIgBoSygABc6WWgAA/veff/0PP8bA//LwY' +
  2105.     'AAA';
  2107. /**
  2108.  * @const {string}
  2109.  * @private
  2110.  */
  2111. // cspell: disable-next-line
  2112. shaka.util.StreamUtils.minAvifImage_ = 'data:image/avif;base64,AAAAIGZ0eXBhdm' +
  2113.     'lmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljd' +
  2114.     'AAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEA' +
  2115.     'AAABAAABGgAAAB0AAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAA' +
  2116.     'AamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAIAAAACAAAAEHBpeGkAAAAAAwgICAAAAA' +
  2117.     'xhdjFDgQ0MAAAAABNjb2xybmNseAACAAIAAYAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAA' +
  2118.     'CVtZGF0EgAKCBgANogQEAwgMg8f8D///8WfhwB8+ErK42A=';
  2120. /**
  2121.  * @const {!Map<string, string>}
  2122.  * @private
  2123.  */
  2124. shaka.util.StreamUtils.minImage_ = new Map()
  2125.     .set('image/webp', shaka.util.StreamUtils.minWebPImage_)
  2126.     .set('image/avif', shaka.util.StreamUtils.minAvifImage_);