shaka-player 4.7.12 → 4.8.0

package/lib/util/stream_utils.js

@@ -263,13 +263,20 @@ shaka.util.StreamUtils = class {
     // |video.width| and |video.height| can be undefined, which breaks
     // the math, so make sure they are there first.
     if (video && video.width && video.height) {
-      if (!inRange(video.width,
+      let videoWidth = video.width;
+      let videoHeight = video.height;
+      if (videoHeight > videoWidth) {
+        // Vertical video.
+        [videoWidth, videoHeight] = [videoHeight, videoWidth];
+      }
+
+      if (!inRange(videoWidth,
           restrictions.minWidth,
           Math.min(restrictions.maxWidth, maxHwRes.width))) {
         return false;
       }
 
-      if (!inRange(video.height,
+      if (!inRange(videoHeight,
           restrictions.minHeight,
           Math.min(restrictions.maxHeight, maxHwRes.height))) {
         return false;
@@ -330,10 +337,12 @@ shaka.util.StreamUtils = class {
    *
    * @param {shaka.media.DrmEngine} drmEngine
    * @param {shaka.extern.Manifest} manifest
+   * @param {!Array<string>=} preferredKeySystems
    */
-  static async filterManifest(drmEngine, manifest) {
+  static async filterManifest(drmEngine, manifest, preferredKeySystems = []) {
     await shaka.util.StreamUtils.filterManifestByMediaCapabilities(
-        drmEngine, manifest, manifest.offlineSessionIds.length > 0);
+        drmEngine, manifest, manifest.offlineSessionIds.length > 0,
+        preferredKeySystems);
     shaka.util.StreamUtils.filterTextStreams_(manifest);
     await shaka.util.StreamUtils.filterImageStreams_(manifest);
   }
@@ -346,15 +355,16 @@ shaka.util.StreamUtils = class {
    * @param {shaka.media.DrmEngine} drmEngine
    * @param {shaka.extern.Manifest} manifest
    * @param {boolean} usePersistentLicenses
+   * @param {!Array<string>} preferredKeySystems
    */
   static async filterManifestByMediaCapabilities(
-      drmEngine, manifest, usePersistentLicenses) {
+      drmEngine, manifest, usePersistentLicenses, preferredKeySystems) {
     goog.asserts.assert(navigator.mediaCapabilities,
         'MediaCapabilities should be valid.');
 
     await shaka.util.StreamUtils.getDecodingInfosForVariants(
         manifest.variants, usePersistentLicenses, /* srcEquals= */ false,
-        /** preferredKeySystems= */ []);
+        preferredKeySystems);
 
     let keySystem = null;
     if (drmEngine) {
@@ -364,115 +374,122 @@ shaka.util.StreamUtils = class {
       }
     }
 
+    const StreamUtils = shaka.util.StreamUtils;
+
+    manifest.variants = manifest.variants.filter((variant) => {
+      const supported = StreamUtils.checkVariantSupported_(variant, keySystem);
+      // Filter out all unsupported variants.
+      if (!supported) {
+        shaka.log.debug('Dropping variant - not compatible with platform',
+            StreamUtils.getVariantSummaryString_(variant));
+      }
+      return supported;
+    });
+  }
+
+
+  /**
+   * @param {!shaka.extern.Variant} variant
+   * @param {?string} keySystem
+   * @return {boolean}
+   * @private
+   */
+  static checkVariantSupported_(variant, keySystem) {
     const ContentType = shaka.util.ManifestParserUtils.ContentType;
     const Capabilities = shaka.media.Capabilities;
     const ManifestParserUtils = shaka.util.ManifestParserUtils;
     const MimeUtils = shaka.util.MimeUtils;
     const StreamUtils = shaka.util.StreamUtils;
-    const isXboxOne = shaka.util.Platform.isXboxOne();
 
+    const isXboxOne = shaka.util.Platform.isXboxOne();
     const isFirefoxAndroid = shaka.util.Platform.isFirefox() &&
         shaka.util.Platform.isAndroid();
 
-    manifest.variants = manifest.variants.filter((variant) => {
-      // See: https://github.com/shaka-project/shaka-player/issues/3860
-      const video = variant.video;
-      const videoWidth = (video && video.width) || 0;
-      const videoHeight = (video && video.height) || 0;
-
-      // See: https://github.com/shaka-project/shaka-player/issues/3380
-      // Note: it makes sense to drop early
-      if (isXboxOne && video &&
-        (videoWidth > 1920 || videoHeight > 1080) &&
-        (video.codecs.includes('avc1.') || video.codecs.includes('avc3.'))
-      ) {
-        shaka.log.debug('Dropping variant - not compatible with platform',
-            StreamUtils.getVariantSummaryString_(variant));
-        return false;
-      }
-
-      if (video) {
-        let videoCodecs = StreamUtils.getCorrectVideoCodecs_(video.codecs);
-        // For multiplexed streams. Here we must check the audio of the
-        // stream to see if it is compatible.
-        if (video.codecs.includes(',')) {
-          const allCodecs = video.codecs.split(',');
-
-          videoCodecs = ManifestParserUtils.guessCodecs(
-              ContentType.VIDEO, allCodecs);
-          videoCodecs = StreamUtils.getCorrectVideoCodecs_(videoCodecs);
-          let audioCodecs = ManifestParserUtils.guessCodecs(
-              ContentType.AUDIO, allCodecs);
-          audioCodecs = StreamUtils.getCorrectAudioCodecs_(audioCodecs);
+    // See: https://github.com/shaka-project/shaka-player/issues/3860
+    const video = variant.video;
+    const videoWidth = (video && video.width) || 0;
+    const videoHeight = (video && video.height) || 0;
 
-          const audioFullType = MimeUtils.getFullOrConvertedType(
-              video.mimeType, audioCodecs, ContentType.AUDIO);
+    // See: https://github.com/shaka-project/shaka-player/issues/3380
+    // Note: it makes sense to drop early
+    if (isXboxOne && video && (videoWidth > 1920 || videoHeight > 1080) &&
+        (video.codecs.includes('avc1.') || video.codecs.includes('avc3.'))) {
+      return false;
+    }
 
-          if (!Capabilities.isTypeSupported(audioFullType)) {
-            return false;
-          }
+    if (video) {
+      let videoCodecs = StreamUtils.getCorrectVideoCodecs(video.codecs);
+      // For multiplexed streams. Here we must check the audio of the
+      // stream to see if it is compatible.
+      if (video.codecs.includes(',')) {
+        const allCodecs = video.codecs.split(',');
 
-          // Update the codec string with the (possibly) converted codecs.
-          videoCodecs = [videoCodecs, audioCodecs].join(',');
-        }
+        videoCodecs = ManifestParserUtils.guessCodecs(
+            ContentType.VIDEO, allCodecs);
+        videoCodecs = StreamUtils.getCorrectVideoCodecs(videoCodecs);
+        let audioCodecs = ManifestParserUtils.guessCodecs(
+            ContentType.AUDIO, allCodecs);
+        audioCodecs = StreamUtils.getCorrectAudioCodecs(audioCodecs);
 
-        const fullType = MimeUtils.getFullOrConvertedType(
-            video.mimeType, videoCodecs, ContentType.VIDEO);
+        const audioFullType = MimeUtils.getFullOrConvertedType(
+            video.mimeType, audioCodecs, ContentType.AUDIO);
 
-        if (!Capabilities.isTypeSupported(fullType)) {
+        if (!Capabilities.isTypeSupported(audioFullType)) {
           return false;
         }
 
         // Update the codec string with the (possibly) converted codecs.
-        video.codecs = videoCodecs;
+        videoCodecs = [videoCodecs, audioCodecs].join(',');
       }
 
-      const audio = variant.audio;
+      const fullType = MimeUtils.getFullOrConvertedType(
+          video.mimeType, videoCodecs, ContentType.VIDEO);
 
-      // See: https://github.com/shaka-project/shaka-player/issues/6111
-      // It seems that Firefox Android reports that it supports
-      // Opus + Widevine, but it is not actually supported.
-      // It makes sense to drop early.
-      if (isFirefoxAndroid && audio && audio.encrypted &&
-          audio.codecs.toLowerCase().includes('opus')) {
-        shaka.log.debug('Dropping variant - not compatible with platform',
-            StreamUtils.getVariantSummaryString_(variant));
+      if (!Capabilities.isTypeSupported(fullType)) {
         return false;
       }
 
-      if (audio) {
-        const codecs = StreamUtils.getCorrectAudioCodecs_(audio.codecs);
-        const fullType = MimeUtils.getFullOrConvertedType(
-            audio.mimeType, codecs, ContentType.AUDIO);
+      // Update the codec string with the (possibly) converted codecs.
+      video.codecs = videoCodecs;
+    }
 
-        if (!Capabilities.isTypeSupported(fullType)) {
-          return false;
-        }
+    const audio = variant.audio;
 
-        // Update the codec string with the (possibly) converted codecs.
-        audio.codecs = codecs;
+    // See: https://github.com/shaka-project/shaka-player/issues/6111
+    // It seems that Firefox Android reports that it supports
+    // Opus + Widevine, but it is not actually supported.
+    // It makes sense to drop early.
+    if (isFirefoxAndroid && audio && audio.encrypted &&
+        audio.codecs.toLowerCase().includes('opus')) {
+      return false;
+    }
+
+    if (audio) {
+      const codecs = StreamUtils.getCorrectAudioCodecs(audio.codecs);
+      const fullType = MimeUtils.getFullOrConvertedType(
+          audio.mimeType, codecs, ContentType.AUDIO);
+
+      if (!Capabilities.isTypeSupported(fullType)) {
+        return false;
       }
 
-      const supported = variant.decodingInfos.some((decodingInfo) => {
-        if (!decodingInfo.supported) {
-          return false;
-        }
-        if (keySystem) {
-          const keySystemAccess = decodingInfo.keySystemAccess;
-          if (keySystemAccess) {
-            if (keySystemAccess.keySystem != keySystem) {
-              return false;
-            }
+      // Update the codec string with the (possibly) converted codecs.
+      audio.codecs = codecs;
+    }
+
+    return variant.decodingInfos.some((decodingInfo) => {
+      if (!decodingInfo.supported) {
+        return false;
+      }
+      if (keySystem) {
+        const keySystemAccess = decodingInfo.keySystemAccess;
+        if (keySystemAccess) {
+          if (keySystemAccess.keySystem != keySystem) {
+            return false;
           }
         }
-        return true;
-      });
-      // Filter out all unsupported variants.
-      if (!supported) {
-        shaka.log.debug('Dropping variant - not compatible with platform',
-            StreamUtils.getVariantSummaryString_(variant));
       }
-      return supported;
+      return true;
     });
   }
 
@@ -516,51 +533,69 @@ shaka.util.StreamUtils = class {
    * and assigns it to the given variant.
    * If that query has been done before, instead return a cached result.
    * @param {!shaka.extern.Variant} variant
-   * @param {!MediaDecodingConfiguration} decodingConfig
+   * @param {!Array.<!MediaDecodingConfiguration>} decodingConfigs
    * @private
    */
-  static async getDecodingInfosForVariant_(variant, decodingConfig) {
-    const cacheKey =
-        shaka.util.StreamUtils.alphabeticalKeyOrderStringify_(decodingConfig);
-
-    const cache = shaka.util.StreamUtils.decodingConfigCache_;
-    if (cache[cacheKey]) {
-      shaka.log.v2('Using cached results of mediaCapabilities.decodingInfo',
-          'for key', cacheKey);
-      variant.decodingInfos.push(cache[cacheKey]);
-    } else {
-      // Do a final pass-over of the decoding config: if a given stream has
-      // multiple codecs, that suggests that it switches between those codecs
-      // at points of the go-through.
-      // mediaCapabilities by itself will report "not supported" when you
-      // put in multiple different codecs, so each has to be checked
-      // individually. So check each and take the worst result, to determine
-      // overall variant compatibility.
-      const results = await shaka.util.StreamUtils
-          .checkEachDecodingConfigCombination_(decodingConfig);
-      if (results && results.length) {
-        /** @type {?MediaCapabilitiesDecodingInfo} */
-        let overallResult = null;
-        for (const result of results) {
-          if (!overallResult) {
-            overallResult = result;
-          } else {
-            overallResult.supported =
-                overallResult.supported && result.supported;
-            overallResult.powerEfficient =
-                overallResult.powerEfficient && result.powerEfficient;
-            overallResult.smooth = overallResult.smooth && result.smooth;
-            if (!result.keySystemAccess) {
-              overallResult.keySystemAccess = null;
-            }
-          }
-        }
-        if (overallResult) {
-          cache[cacheKey] = overallResult;
-          variant.decodingInfos.push(overallResult);
+  static async getDecodingInfosForVariant_(variant, decodingConfigs) {
+    /**
+     * @param {?MediaCapabilitiesDecodingInfo} a
+     * @param {!MediaCapabilitiesDecodingInfo} b
+     * @return {!MediaCapabilitiesDecodingInfo}
+     */
+    const merge = (a, b) => {
+      if (!a) {
+        return b;
+      } else {
+        const res = shaka.util.ObjectUtils.cloneObject(a);
+        res.supported = a.supported && b.supported;
+        res.powerEfficient = a.powerEfficient && b.powerEfficient;
+        res.smooth = a.smooth && b.smooth;
+        if (b.keySystemAccess && !res.keySystemAccess) {
+          res.keySystemAccess = b.keySystemAccess;
         }
+        return res;
+      }
+    };
+
+    const StreamUtils = shaka.util.StreamUtils;
+    /** @type {?MediaCapabilitiesDecodingInfo} */
+    let finalResult = null;
+    const promises = [];
+    for (const decodingConfig of decodingConfigs) {
+      const cacheKey =
+          StreamUtils.alphabeticalKeyOrderStringify_(decodingConfig);
+
+      const cache = StreamUtils.decodingConfigCache_;
+      if (cache[cacheKey]) {
+        shaka.log.v2('Using cached results of mediaCapabilities.decodingInfo',
+            'for key', cacheKey);
+        finalResult = merge(finalResult, cache[cacheKey]);
+      } else {
+        // Do a final pass-over of the decoding config: if a given stream has
+        // multiple codecs, that suggests that it switches between those codecs
+        // at points of the go-through.
+        // mediaCapabilities by itself will report "not supported" when you
+        // put in multiple different codecs, so each has to be checked
+        // individually. So check each and take the worst result, to determine
+        // overall variant compatibility.
+        promises.push(StreamUtils
+            .checkEachDecodingConfigCombination_(decodingConfig).then((res) => {
+              /** @type {?MediaCapabilitiesDecodingInfo} */
+              let acc = null;
+              for (const result of (res || [])) {
+                acc = merge(acc, result);
+              }
+              if (acc) {
+                cache[cacheKey] = acc;
+                finalResult = merge(finalResult, acc);
+              }
+            }));
       }
     }
+    await Promise.all(promises);
+    if (finalResult) {
+      variant.decodingInfos.push(finalResult);
+    }
   }
 
   /**
@@ -634,10 +669,12 @@ shaka.util.StreamUtils = class {
     for (const preferredKeySystem of preferredKeySystems) {
       let keySystemSatisfied = false;
       for (const variant of variants) {
-        /** @type {!Array.<!MediaDecodingConfiguration>} */
+        /** @type {!Array.<!Array.<!MediaDecodingConfiguration>>} */
         const decodingConfigs = shaka.util.StreamUtils.getDecodingConfigs_(
             variant, usePersistentLicenses, srcEquals)
-            .filter((config) => {
+            .filter((configs) => {
+              // All configs in a batch will have the same keySystem.
+              const config = configs[0];
               const keySystem = config.keySystemConfiguration &&
                 config.keySystemConfiguration.keySystem;
               return keySystem === preferredKeySystem;
@@ -646,10 +683,10 @@ shaka.util.StreamUtils = class {
         // The reason we are performing this await in a loop rather than
         // batching into a `promise.all` is performance related.
         // https://github.com/shaka-project/shaka-player/pull/4708#discussion_r1022581178
-        for (const config of decodingConfigs) {
+        for (const configs of decodingConfigs) {
           // eslint-disable-next-line no-await-in-loop
           await shaka.util.StreamUtils.getDecodingInfosForVariant_(
-              variant, config);
+              variant, configs);
         }
         if (variant.decodingInfos.length) {
           keySystemSatisfied = true;
@@ -662,10 +699,12 @@ shaka.util.StreamUtils = class {
     } // for (const preferredKeySystem of preferredKeySystems)
 
     for (const variant of variants) {
-      /** @type {!Array.<!MediaDecodingConfiguration>} */
+      /** @type {!Array.<!Array.<!MediaDecodingConfiguration>>} */
       const decodingConfigs = shaka.util.StreamUtils.getDecodingConfigs_(
           variant, usePersistentLicenses, srcEquals)
-          .filter((config) => {
+          .filter((configs) => {
+            // All configs in a batch will have the same keySystem.
+            const config = configs[0];
             const keySystem = config.keySystemConfiguration &&
               config.keySystemConfiguration.keySystem;
             // Avoid checking preferred systems twice.
@@ -675,22 +714,24 @@ shaka.util.StreamUtils = class {
       // The reason we are performing this await in a loop rather than
       // batching into a `promise.all` is performance related.
       // https://github.com/shaka-project/shaka-player/pull/4708#discussion_r1022581178
-      for (const config of decodingConfigs) {
+      for (const configs of decodingConfigs) {
         // eslint-disable-next-line no-await-in-loop
         await shaka.util.StreamUtils.getDecodingInfosForVariant_(
-            variant, config);
+            variant, configs);
       }
     }
   }
 
 
   /**
-   * Generate a MediaDecodingConfiguration object to get the decodingInfo
-   * results for each variant.
+   * Generate a batch of MediaDecodingConfiguration objects to get the
+   * decodingInfo results for each variant.
+   * Each batch shares the same DRM information, and represents the various
+   * fullMimeType combinations of the streams.
    * @param {!shaka.extern.Variant} variant
    * @param {boolean} usePersistentLicenses
    * @param {boolean} srcEquals
-   * @return {!Array.<!MediaDecodingConfiguration>}
+   * @return {!Array.<!Array.<!MediaDecodingConfiguration>>}
    * @private
    */
   static getDecodingConfigs_(variant, usePersistentLicenses, srcEquals) {
@@ -702,87 +743,118 @@ shaka.util.StreamUtils = class {
     const MimeUtils = shaka.util.MimeUtils;
     const StreamUtils = shaka.util.StreamUtils;
 
-    /** @type {!MediaDecodingConfiguration} */
-    const mediaDecodingConfig = {
-      type: srcEquals ? 'file' : 'media-source',
-    };
-
+    const videoConfigs = [];
+    const audioConfigs = [];
     if (video) {
-      let videoCodecs = video.codecs;
+      for (const fullMimeType of video.fullMimeTypes) {
+        let videoCodecs = MimeUtils.getCodecs(fullMimeType);
 
-      // For multiplexed streams with audio+video codecs, the config should have
-      // AudioConfiguration and VideoConfiguration.
-      if (video.codecs.includes(',')) {
-        const allCodecs = video.codecs.split(',');
+        // For multiplexed streams with audio+video codecs, the config should
+        // have AudioConfiguration and VideoConfiguration.
+        // We ignore the multiplexed audio when there is normal audio also.
+        if (videoCodecs.includes(',') && !audio) {
+          const allCodecs = videoCodecs.split(',');
 
-        videoCodecs = ManifestParserUtils.guessCodecs(
-            ContentType.VIDEO, allCodecs);
-        videoCodecs = StreamUtils.getCorrectVideoCodecs_(videoCodecs);
+          videoCodecs = ManifestParserUtils.guessCodecs(
+              ContentType.VIDEO, allCodecs);
 
-        let audioCodecs = ManifestParserUtils.guessCodecs(
-            ContentType.AUDIO, allCodecs);
-        audioCodecs = StreamUtils.getCorrectAudioCodecs_(audioCodecs);
+          let audioCodecs = ManifestParserUtils.guessCodecs(
+              ContentType.AUDIO, allCodecs);
+          audioCodecs = StreamUtils.getCorrectAudioCodecs(audioCodecs);
 
-        const audioFullType = MimeUtils.getFullOrConvertedType(
-            video.mimeType, audioCodecs, ContentType.AUDIO);
+          const audioFullType = MimeUtils.getFullOrConvertedType(
+              MimeUtils.getBasicType(fullMimeType), audioCodecs,
+              ContentType.AUDIO);
+
+          audioConfigs.push({
+            contentType: audioFullType,
+            channels: 2,
+            bitrate: variant.bandwidth || 1,
+            samplerate: 1,
+            spatialRendering: false,
+          });
+        }
 
-        mediaDecodingConfig.audio = {
-          contentType: audioFullType,
-          channels: 2,
-          bitrate: variant.bandwidth || 1,
-          samplerate: 1,
-          spatialRendering: false,
+        videoCodecs = StreamUtils.getCorrectVideoCodecs(videoCodecs);
+        const fullType = MimeUtils.getFullOrConvertedType(
+            MimeUtils.getBasicType(fullMimeType), videoCodecs,
+            ContentType.VIDEO);
+
+        // VideoConfiguration
+        const videoConfig = {
+          contentType: fullType,
+
+          // NOTE: Some decoders strictly check the width and height fields and
+          // won't decode smaller than 64x64.  So if we don't have this info (as
+          // is the case in some of our simpler tests), assume a 64x64
+          // resolution to fill in this required field for MediaCapabilities.
+          //
+          // This became an issue specifically on Firefox on M1 Macs.
+          width: video.width || 64,
+          height: video.height || 64,
+
+          bitrate: video.bandwidth || variant.bandwidth || 1,
+          // framerate must be greater than 0, otherwise the config is invalid.
+          framerate: video.frameRate || 1,
         };
-      }
-
-      videoCodecs = StreamUtils.getCorrectVideoCodecs_(videoCodecs);
-      const fullType = MimeUtils.getFullOrConvertedType(
-          video.mimeType, videoCodecs, ContentType.VIDEO);
-
-      // VideoConfiguration
-      mediaDecodingConfig.video = {
-        contentType: fullType,
-
-        // NOTE: Some decoders strictly check the width and height fields and
-        // won't decode smaller than 64x64.  So if we don't have this info (as
-        // is the case in some of our simpler tests), assume a 64x64 resolution
-        // to fill in this required field for MediaCapabilities.
-        //
-        // This became an issue specifically on Firefox on M1 Macs.
-        width: video.width || 64,
-        height: video.height || 64,
-
-        bitrate: video.bandwidth || variant.bandwidth || 1,
-        // framerate must be greater than 0, otherwise the config is invalid.
-        framerate: video.frameRate || 1,
-      };
-      if (video.hdr) {
-        switch (video.hdr) {
-          case 'SDR':
-            mediaDecodingConfig.video.transferFunction = 'srgb';
-            break;
-          case 'PQ':
-            mediaDecodingConfig.video.transferFunction = 'pq';
-            break;
-          case 'HLG':
-            mediaDecodingConfig.video.transferFunction = 'hlg';
-            break;
+        if (video.hdr) {
+          switch (video.hdr) {
+            case 'SDR':
+              videoConfig.transferFunction = 'srgb';
+              break;
+            case 'PQ':
+              videoConfig.transferFunction = 'pq';
+              break;
+            case 'HLG':
+              videoConfig.transferFunction = 'hlg';
+              break;
+          }
         }
+        videoConfigs.push(videoConfig);
       }
     }
     if (audio) {
-      const codecs = StreamUtils.getCorrectAudioCodecs_(audio.codecs);
-      const fullType = MimeUtils.getFullOrConvertedType(
-          audio.mimeType, codecs, ContentType.AUDIO);
+      for (const fullMimeType of audio.fullMimeTypes) {
+        const codecs = StreamUtils.getCorrectAudioCodecs(MimeUtils.getCodecs(
+            fullMimeType));
+        const fullType = MimeUtils.getFullOrConvertedType(
+            MimeUtils.getBasicType(fullMimeType), codecs, ContentType.AUDIO);
+
+        // AudioConfiguration
+        audioConfigs.push({
+          contentType: fullType,
+          channels: audio.channelsCount || 2,
+          bitrate: audio.bandwidth || variant.bandwidth || 1,
+          samplerate: audio.audioSamplingRate || 1,
+          spatialRendering: audio.spatialAudio,
+        });
+      }
+    }
 
-      // AudioConfiguration
-      mediaDecodingConfig.audio = {
-        contentType: fullType,
-        channels: audio.channelsCount || 2,
-        bitrate: audio.bandwidth || variant.bandwidth || 1,
-        samplerate: audio.audioSamplingRate || 1,
-        spatialRendering: audio.spatialAudio,
-      };
+    // Generate each combination of video and audio config as a separate
+    // MediaDecodingConfiguration, inside the main "batch".
+    /** @type {!Array.<!MediaDecodingConfiguration>} */
+    const mediaDecodingConfigBatch = [];
+    if (videoConfigs.length == 0) {
+      videoConfigs.push(null);
+    }
+    if (audioConfigs.length == 0) {
+      audioConfigs.push(null);
+    }
+    for (const videoConfig of videoConfigs) {
+      for (const audioConfig of audioConfigs) {
+        /** @type {!MediaDecodingConfiguration} */
+        const mediaDecodingConfig = {
+          type: srcEquals ? 'file' : 'media-source',
+        };
+        if (videoConfig) {
+          mediaDecodingConfig.video = videoConfig;
+        }
+        if (audioConfig) {
+          mediaDecodingConfig.audio = audioConfig;
+        }
+        mediaDecodingConfigBatch.push(mediaDecodingConfig);
+      }
     }
 
     const videoDrmInfos = variant.video ? variant.video.drmInfos : [];
@@ -791,7 +863,7 @@ shaka.util.StreamUtils = class {
 
     // Return a list containing the mediaDecodingConfig for unencrypted variant.
     if (!allDrmInfos.length) {
-      return [mediaDecodingConfig];
+      return [mediaDecodingConfigBatch];
     }
 
     // A list of MediaDecodingConfiguration objects created for the variant.
@@ -813,83 +885,87 @@ shaka.util.StreamUtils = class {
         usePersistentLicenses ? ['persistent-license'] : ['temporary'];
 
     for (const keySystem of drmInfoByKeySystems.keys()) {
-      // Create a copy of the mediaDecodingConfig.
-      const config = /** @type {!MediaDecodingConfiguration} */
-          (Object.assign({}, mediaDecodingConfig));
-
-      const drmInfos = drmInfoByKeySystems.get(keySystem);
-
-      /** @type {!MediaCapabilitiesKeySystemConfiguration} */
-      const keySystemConfig = {
-        keySystem: keySystem,
-        initDataType: 'cenc',
-        persistentState: persistentState,
-        distinctiveIdentifier: 'optional',
-        sessionTypes: sessionTypes,
-      };
-
-      for (const info of drmInfos) {
-        if (info.initData && info.initData.length) {
-          const initDataTypes = new Set();
-          for (const initData of info.initData) {
-            initDataTypes.add(initData.initDataType);
-          }
-          if (initDataTypes.size > 1) {
-            shaka.log.v2('DrmInfo contains more than one initDataType,',
-                'and we use the initDataType of the first initData.',
-                info);
+      const modifiedMediaDecodingConfigBatch = [];
+      for (const base of mediaDecodingConfigBatch) {
+        // Create a copy of the mediaDecodingConfig.
+        const config = /** @type {!MediaDecodingConfiguration} */
+            (Object.assign({}, base));
+
+        const drmInfos = drmInfoByKeySystems.get(keySystem);
+
+        /** @type {!MediaCapabilitiesKeySystemConfiguration} */
+        const keySystemConfig = {
+          keySystem: keySystem,
+          initDataType: 'cenc',
+          persistentState: persistentState,
+          distinctiveIdentifier: 'optional',
+          sessionTypes: sessionTypes,
+        };
+
+        for (const info of drmInfos) {
+          if (info.initData && info.initData.length) {
+            const initDataTypes = new Set();
+            for (const initData of info.initData) {
+              initDataTypes.add(initData.initDataType);
+            }
+            if (initDataTypes.size > 1) {
+              shaka.log.v2('DrmInfo contains more than one initDataType,',
+                  'and we use the initDataType of the first initData.',
+                  info);
+            }
+            keySystemConfig.initDataType = info.initData[0].initDataType;
           }
-          keySystemConfig.initDataType = info.initData[0].initDataType;
-        }
 
-        if (info.distinctiveIdentifierRequired) {
-          keySystemConfig.distinctiveIdentifier = 'required';
-        }
-        if (info.persistentStateRequired) {
-          keySystemConfig.persistentState = 'required';
-        }
-        if (info.sessionType) {
-          keySystemConfig.sessionTypes = [info.sessionType];
-        }
+          if (info.distinctiveIdentifierRequired) {
+            keySystemConfig.distinctiveIdentifier = 'required';
+          }
+          if (info.persistentStateRequired) {
+            keySystemConfig.persistentState = 'required';
+          }
+          if (info.sessionType) {
+            keySystemConfig.sessionTypes = [info.sessionType];
+          }
 
-        if (audio) {
-          // See: https://github.com/shaka-project/shaka-player/issues/4659
-          if (info.audioRobustness != '') {
-            if (!keySystemConfig.audio) {
+          if (audio) {
+            // See: https://github.com/shaka-project/shaka-player/issues/4659
+            if (info.audioRobustness != '') {
+              if (!keySystemConfig.audio) {
+                // KeySystemTrackConfiguration
+                keySystemConfig.audio = {
+                  robustness: info.audioRobustness,
+                };
+              } else {
+                keySystemConfig.audio.robustness =
+                    keySystemConfig.audio.robustness || info.audioRobustness;
+              }
+            } else if (!keySystemConfig.audio) {
               // KeySystemTrackConfiguration
-              keySystemConfig.audio = {
-                robustness: info.audioRobustness,
-              };
-            } else {
-              keySystemConfig.audio.robustness =
-                  keySystemConfig.audio.robustness || info.audioRobustness;
+              keySystemConfig.audio = {};
             }
-          } else if (!keySystemConfig.audio) {
-            // KeySystemTrackConfiguration
-            keySystemConfig.audio = {};
           }
-        }
 
-        if (video) {
-          // See: https://github.com/shaka-project/shaka-player/issues/4659
-          if (info.videoRobustness != '') {
-            if (!keySystemConfig.video) {
+          if (video) {
+            // See: https://github.com/shaka-project/shaka-player/issues/4659
+            if (info.videoRobustness != '') {
+              if (!keySystemConfig.video) {
+                // KeySystemTrackConfiguration
+                keySystemConfig.video = {
+                  robustness: info.videoRobustness,
+                };
+              } else {
+                keySystemConfig.video.robustness =
+                    keySystemConfig.video.robustness || info.videoRobustness;
+              }
+            } else if (!keySystemConfig.video) {
               // KeySystemTrackConfiguration
-              keySystemConfig.video = {
-                robustness: info.videoRobustness,
-              };
-            } else {
-              keySystemConfig.video.robustness =
-                  keySystemConfig.video.robustness || info.videoRobustness;
+              keySystemConfig.video = {};
             }
-          } else if (!keySystemConfig.video) {
-            // KeySystemTrackConfiguration
-            keySystemConfig.video = {};
           }
         }
+        config.keySystemConfiguration = keySystemConfig;
+        modifiedMediaDecodingConfigBatch.push(config);
       }
-      config.keySystemConfiguration = keySystemConfig;
-      configs.push(config);
+      configs.push(modifiedMediaDecodingConfigBatch);
     }
     return configs;
   }
@@ -900,9 +976,8 @@ shaka.util.StreamUtils = class {
    * for MediaSource.isTypeSupported.
    * @param {string} codecs
    * @return {string}
-   * @private
    */
-  static getCorrectAudioCodecs_(codecs) {
+  static getCorrectAudioCodecs(codecs) {
     // According to RFC 6381 section 3.3, 'fLaC' is actually the correct
     // codec string. We still need to map it to 'flac', as some browsers
     // currently don't support 'fLaC', while 'flac' is supported by most
@@ -926,9 +1001,8 @@ shaka.util.StreamUtils = class {
    * for MediaSource.isTypeSupported.
    * @param {string} codec
    * @return {string}
-   * @private
    */
-  static getCorrectVideoCodecs_(codec) {
+  static getCorrectVideoCodecs(codec) {
     if (codec.includes('avc1')) {
       // Convert avc1 codec string from RFC-4281 to RFC-6381 for
       // MediaSource.isTypeSupported
@@ -1390,8 +1464,6 @@ shaka.util.StreamUtils = class {
    * @return {shaka.extern.Track}
    */
   static html5TextTrackToTrack(textTrack) {
-    const CLOSED_CAPTION_MIMETYPE =
-        shaka.util.MimeUtils.CEA608_CLOSED_CAPTION_MIMETYPE;
     const StreamUtils = shaka.util.StreamUtils;
 
     /** @type {shaka.extern.Track} */
@@ -1400,7 +1472,8 @@ shaka.util.StreamUtils = class {
     track.type = 'text';
     track.originalTextId = textTrack.id;
     if (textTrack.kind == 'captions') {
-      track.mimeType = CLOSED_CAPTION_MIMETYPE;
+      // See: https://github.com/shaka-project/shaka-player/issues/6233
+      track.mimeType = 'unknown';
     }
     if (textTrack.kind == 'subtitles') {
       track.mimeType = 'text/vtt';