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