shaka-player 4.4.3 → 4.5.0

package/lib/util/stream_utils.js

@@ -7,6 +7,7 @@
 goog.provide('shaka.util.StreamUtils');
 
 goog.require('goog.asserts');
+goog.require('shaka.config.CodecSwitchingStrategy');
 goog.require('shaka.log');
 goog.require('shaka.media.Capabilities');
 goog.require('shaka.text.TextEngine');
@@ -38,103 +39,148 @@ shaka.util.StreamUtils = class {
       preferredAudioCodecs, preferredAudioChannelCount,
       preferredDecodingAttributes) {
     const StreamUtils = shaka.util.StreamUtils;
+    const MimeUtils = shaka.util.MimeUtils;
 
     let variants = manifest.variants;
-
     // To start, choose the codecs based on configured preferences if available.
     if (preferredVideoCodecs.length || preferredAudioCodecs.length) {
       variants = StreamUtils.choosePreferredCodecs(variants,
           preferredVideoCodecs, preferredAudioCodecs);
     }
 
-    // Consider a subset of variants based on audio channel
-    // preferences.
-    // For some content (#1013), surround-sound variants will use a different
-    // codec than stereo variants, so it is important to choose codecs **after**
-    // considering the audio channel config.
-    variants = StreamUtils.filterVariantsByAudioChannelCount(
-        variants, preferredAudioChannelCount);
-
-    // Now organize variants into buckets by codecs.
-    /** @type {!shaka.util.MultiMap.<shaka.extern.Variant>} */
-    let variantsByCodecs = StreamUtils.getVariantsByCodecs_(variants);
-    variantsByCodecs = StreamUtils.filterVariantsByDensity_(variantsByCodecs);
+    if (preferredDecodingAttributes.length) {
+      // group variants by resolution and choose preferred variants only
+      /** @type {!shaka.util.MultiMap.<shaka.extern.Variant>} */
+      const variantsByResolutionMap = new shaka.util.MultiMap();
+      for (const variant of variants) {
+        variantsByResolutionMap
+            .push(String(variant.video.width || 0), variant);
+      }
+      const bestVariants = [];
+      variantsByResolutionMap.forEach((width, variantsByResolution) => {
+        let highestMatch = 0;
+        let matchingVariants = [];
+        for (const variant of variantsByResolution) {
+          const matchCount = preferredDecodingAttributes.filter(
+              (attribute) => variant.decodingInfos[0][attribute],
+          ).length;
+          if (matchCount > highestMatch) {
+            highestMatch = matchCount;
+            matchingVariants = [variant];
+          } else if (matchCount == highestMatch) {
+            matchingVariants.push(variant);
+          }
+        }
+        bestVariants.push(...matchingVariants);
+      });
+      variants = bestVariants;
+    }
 
-    const bestCodecs = StreamUtils.chooseCodecsByDecodingAttributes_(
-        variantsByCodecs, preferredDecodingAttributes);
+    if (preferredAudioChannelCount) {
+      variants = StreamUtils.filterVariantsByAudioChannelCount(
+          variants, preferredAudioChannelCount);
+    }
 
-    // Filter out any variants that don't match, forcing AbrManager to choose
-    // from a single video codec and a single audio codec possible.
-    manifest.variants = manifest.variants.filter((variant) => {
-      const codecs = StreamUtils.getVariantCodecs_(variant);
-      if (codecs == bestCodecs) {
-        return true;
+    const audioStreamsSet = new Set();
+    const videoStreamsSet = new Set();
+    for (const variant of variants) {
+      if (variant.audio) {
+        audioStreamsSet.add(variant.audio);
+      }
+      if (variant.video) {
+        videoStreamsSet.add(variant.video);
       }
+    }
 
-      shaka.log.debug('Dropping Variant (better codec available)', variant);
-      return false;
+    const audioStreams = Array.from(audioStreamsSet).sort((v1, v2) => {
+      return v1.bandwidth - v2.bandwidth;
     });
-  }
-
-  /**
-  * Get variants by codecs.
-  *
-  * @param {!Array<shaka.extern.Variant>} variants
-  * @return {!shaka.util.MultiMap.<shaka.extern.Variant>}
-  * @private
-  */
-  static getVariantsByCodecs_(variants) {
-    const variantsByCodecs = new shaka.util.MultiMap();
-    for (const variant of variants) {
-      const variantCodecs = shaka.util.StreamUtils.getVariantCodecs_(variant);
-      variantsByCodecs.push(variantCodecs, variant);
+    const audioStreamsMap = new Map();
+    const getAudioId = (stream) => {
+      return stream.language + (stream.channelsCount || 0) +
+        stream.roles.join(',') + stream.label;
+    };
+    for (const stream of audioStreams) {
+      const id = getAudioId(stream);
+      if (!audioStreamsMap.has(id)) {
+        audioStreamsMap.set(id, stream);
+      } else {
+        const includedStream = audioStreamsMap.get(id);
+        if (includedStream.bandwidth > stream.bandwidth) {
+          audioStreamsMap.set(id, stream);
+        }
+      }
     }
+    const validAudioStreams = [...audioStreamsMap.values()];
 
-    return variantsByCodecs;
-  }
+    const videoStreams = Array.from(videoStreamsSet)
+        .sort((v1, v2) => {
+          if (!v1.bandwidth || !v2.bandwidth) {
+            return v1.width - v2.width;
+          }
+          return v1.bandwidth - v2.bandwidth;
+        });
 
-  /**
-  * Filters variants by density.
-  * Get variants by codecs map with the max density where all codecs are
-  * present.
-  *
-  * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
-  * @return {!shaka.util.MultiMap.<shaka.extern.Variant>}
-  * @private
-  */
-  static filterVariantsByDensity_(variantsByCodecs) {
-    let maxDensity = 0;
-    const codecGroupsByDensity = new Map();
-    const countCodecs = variantsByCodecs.size();
-
-    variantsByCodecs.forEach((codecs, variants) => {
-      for (const variant of variants) {
-        const video = variant.video;
-        if (!video || !video.width || !video.height) {
-          continue;
-        }
+    const isChangeTypeSupported =
+      shaka.media.Capabilities.isChangeTypeSupported();
 
-        const density = video.width * video.height * (video.frameRate || 1);
-        if (!codecGroupsByDensity.has(density)) {
-          codecGroupsByDensity.set(density, new shaka.util.MultiMap());
+    const validVideoStreams = [];
+    for (const stream of videoStreams) {
+      if (!validVideoStreams.length) {
+        validVideoStreams.push(stream);
+      } else {
+        const previousStream = validVideoStreams[validVideoStreams.length - 1];
+        if (!isChangeTypeSupported) {
+          const previousCodec =
+            MimeUtils.getNormalizedCodec(previousStream.codecs);
+          const currentCodec =
+            MimeUtils.getNormalizedCodec(stream.codecs);
+          if (previousCodec !== currentCodec) {
+            continue;
+          }
+        }
+        if (stream.width > previousStream.width ||
+          stream.height > previousStream.height) {
+          validVideoStreams.push(stream);
+        } else if (stream.width == previousStream.width &&
+          stream.height == previousStream.height) {
+          const previousCodec =
+            MimeUtils.getNormalizedCodec(previousStream.codecs);
+          const currentCodec =
+            MimeUtils.getNormalizedCodec(stream.codecs);
+          if (previousCodec == currentCodec) {
+            if (stream.bandwidth < previousStream.bandwidth) {
+              validVideoStreams.push(stream);
+            }
+          }
         }
+      }
+    }
 
-        /** @type {!shaka.util.MultiMap.<shaka.extern.Variant>} */
-        const group = codecGroupsByDensity.get(density);
-        group.push(codecs, variant);
-
-        // We want to look at the groups in which all codecs are present.
-        // Take the max density from those groups where all codecs are present.
-        // Later, we will compare bandwidth numbers only within this group.
-        // Effectively, only the bandwidth differences in the highest-res and
-        // highest-framerate content will matter in choosing a codec.
-        if (group.size() === countCodecs) {
-          maxDensity = Math.max(maxDensity, density);
+    const validAudioIds =
+      validAudioStreams.map((audioStream) => audioStream.id);
+    const validVideoIds =
+      validVideoStreams.map((videoStream) => videoStream.id);
+
+    // Filter out any variants that don't match, forcing AbrManager to choose
+    // from a single video codec and a single audio codec possible.
+    manifest.variants = manifest.variants.filter((variant) => {
+      const audio = variant.audio;
+      const video = variant.video;
+      if (audio) {
+        if (!validAudioIds.includes(audio.id)) {
+          shaka.log.debug('Dropping Variant (better codec available)', variant);
+          return false;
+        }
+      }
+      if (video) {
+        if (!validVideoIds.includes(video.id)) {
+          shaka.log.debug('Dropping Variant (better codec available)', variant);
+          return false;
         }
       }
+      return true;
     });
-
-    return maxDensity ? codecGroupsByDensity.get(maxDensity) : variantsByCodecs;
   }
 
   /**
@@ -170,135 +216,6 @@ shaka.util.StreamUtils = class {
     return subset;
   }
 
-  /**
-   * Choose the codecs by configured preferred decoding attributes.
-   *
-   * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
-   * @param {!Array.<string>} attributes
-   * @return {string}
-   * @private
-   */
-  static chooseCodecsByDecodingAttributes_(variantsByCodecs, attributes) {
-    const StreamUtils = shaka.util.StreamUtils;
-
-    for (const attribute of attributes) {
-      if (attribute == StreamUtils.DecodingAttributes.SMOOTH ||
-          attribute == StreamUtils.DecodingAttributes.POWER) {
-        variantsByCodecs = StreamUtils.chooseCodecsByMediaCapabilitiesInfo_(
-            variantsByCodecs, attribute);
-        // If we only have one smooth or powerEfficient codecs, choose it as the
-        // best codecs.
-        if (variantsByCodecs.size() == 1) {
-          return variantsByCodecs.keys()[0];
-        }
-      } else if (attribute == StreamUtils.DecodingAttributes.BANDWIDTH) {
-        return StreamUtils.findCodecsByLowestBandwidth_(variantsByCodecs);
-      }
-    }
-    // If there's no configured decoding preferences, or we have multiple codecs
-    // that meets the configured decoding preferences, choose the one with
-    // the lowest bandwidth.
-    return StreamUtils.findCodecsByLowestBandwidth_(variantsByCodecs);
-  }
-
-  /**
-   * Choose the best codecs by configured preferred MediaCapabilitiesInfo
-   * attributes.
-   *
-   * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
-   * @param {string} attribute
-   * @return {!shaka.util.MultiMap.<shaka.extern.Variant>}
-   * @private
-   */
-  static chooseCodecsByMediaCapabilitiesInfo_(variantsByCodecs, attribute) {
-    let highestScore = 0;
-    const bestVariantsByCodecs = new shaka.util.MultiMap();
-    variantsByCodecs.forEach((codecs, variants) => {
-      let sum = 0;
-      let num = 0;
-
-      for (const variant of variants) {
-        if (variant.decodingInfos.length) {
-          sum += variant.decodingInfos[0][attribute] ? 1 : 0;
-          num++;
-        }
-      }
-
-      const averageScore = sum / num;
-      shaka.log.debug('codecs', codecs, 'avg', attribute, averageScore);
-
-      if (averageScore > highestScore) {
-        bestVariantsByCodecs.clear();
-        bestVariantsByCodecs.push(codecs, variants);
-        highestScore = averageScore;
-      } else if (averageScore == highestScore) {
-        bestVariantsByCodecs.push(codecs, variants);
-      }
-    });
-    return bestVariantsByCodecs;
-  }
-
-  /**
-   * Find the lowest-bandwidth (best) codecs.
-   * Compute the average bandwidth for each group of variants.
-   *
-   * @param {!shaka.util.MultiMap.<shaka.extern.Variant>} variantsByCodecs
-   * @return {string}
-   * @private
-   */
-  static findCodecsByLowestBandwidth_(variantsByCodecs) {
-    let bestCodecs = '';
-    let lowestAverageBandwidth = Infinity;
-
-    variantsByCodecs.forEach((codecs, variants) => {
-      let sum = 0;
-      let num = 0;
-      for (const variant of variants) {
-        sum += variant.bandwidth || 0;
-        ++num;
-      }
-
-      const averageBandwidth = sum / num;
-      shaka.log.debug('codecs', codecs, 'avg bandwidth', averageBandwidth);
-
-      if (averageBandwidth < lowestAverageBandwidth) {
-        bestCodecs = codecs;
-        lowestAverageBandwidth = averageBandwidth;
-      }
-    });
-
-    goog.asserts.assert(bestCodecs !== '', 'Should have chosen codecs!');
-    goog.asserts.assert(!isNaN(lowestAverageBandwidth),
-        'Bandwidth should be a number!');
-
-    return bestCodecs;
-  }
-
-  /**
-   * Get a string representing all codecs used in a variant.
-   *
-   * @param {!shaka.extern.Variant} variant
-   * @return {string}
-   * @private
-   */
-  static getVariantCodecs_(variant) {
-    // Only consider the base of the codec string.  For example, these should
-    // both be considered the same codec: avc1.42c01e, avc1.4d401f
-    let baseVideoCodec = '';
-    if (variant.video) {
-      baseVideoCodec =
-        shaka.util.MimeUtils.getNormalizedCodec(variant.video.codecs);
-    }
-
-    let baseAudioCodec = '';
-    if (variant.audio) {
-      baseAudioCodec =
-        shaka.util.MimeUtils.getNormalizedCodec(variant.audio.codecs);
-    }
-
-    return baseVideoCodec + '-' + baseAudioCodec;
-  }
-
   /**
    * Filter the variants in |manifest| to only include the variants that meet
    * the given restrictions.
@@ -404,12 +321,12 @@ shaka.util.StreamUtils = class {
    * @param {shaka.media.DrmEngine} drmEngine
    * @param {?shaka.extern.Variant} currentVariant
    * @param {shaka.extern.Manifest} manifest
+   * @param {shaka.config.CodecSwitchingStrategy=} codecSwitchingStrategy
    */
-  static async filterManifest(drmEngine, currentVariant, manifest) {
+  static async filterManifest(drmEngine, currentVariant, manifest,
+      codecSwitchingStrategy=shaka.config.CodecSwitchingStrategy.RELOAD) {
     await shaka.util.StreamUtils.filterManifestByMediaCapabilities(manifest,
         manifest.offlineSessionIds.length > 0);
-    shaka.util.StreamUtils.filterManifestByCurrentVariant(
-        currentVariant, manifest);
     shaka.util.StreamUtils.filterTextStreams_(manifest);
     await shaka.util.StreamUtils.filterImageStreams_(manifest);
   }
@@ -1510,6 +1427,7 @@ shaka.util.StreamUtils = class {
 
     /** @type {!Map.<number, !Array.<shaka.extern.Variant>>} */
     const variantsByChannelCount = new Map();
+    const capableVariants = [];
     for (const variant of variantsWithChannelCounts) {
       const count = variant.audio.channelsCount;
       goog.asserts.assert(count != null, 'Must have count after filtering!');
@@ -1517,6 +1435,14 @@ shaka.util.StreamUtils = class {
         variantsByChannelCount.set(count, []);
       }
       variantsByChannelCount.get(count).push(variant);
+      if (count <= preferredAudioChannelCount) {
+        capableVariants.push(variant);
+      }
+    }
+
+    // return all capable channelcounts
+    if (capableVariants.length) {
+      return capableVariants;
     }
 
     /** @type {!Array.<number>} */
@@ -1527,15 +1453,6 @@ shaka.util.StreamUtils = class {
       return variants;
     }
 
-    // Choose the variants with the largest number of audio channels less than
-    // or equal to the configured number of audio channels.
-    const countLessThanOrEqualtoConfig =
-        channelCounts.filter((count) => count <= preferredAudioChannelCount);
-    if (countLessThanOrEqualtoConfig.length) {
-      return variantsByChannelCount.get(
-          Math.max(...countLessThanOrEqualtoConfig));
-    }
-
     // If all variants have more audio channels than the config, choose the
     // variants with the fewest audio channels.
     return variantsByChannelCount.get(Math.min(...channelCounts));
@@ -1762,7 +1679,6 @@ shaka.util.StreamUtils.nextTrackId_ = 0;
 shaka.util.StreamUtils.DecodingAttributes = {
   SMOOTH: 'smooth',
   POWER: 'powerEfficient',
-  BANDWIDTH: 'bandwidth',
 };
 
 /**