Source: lib/util/stream_utils.js

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