Source: lib/media/adaptation_set.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.media.AdaptationSet');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.util.MimeUtils');
  14. /**
  15.  * A set of variants that we want to adapt between.
  16.  *
  17.  * @final
  18.  * @export
  19.  */
  20. shaka.media.AdaptationSet = class {
  21.   /**
  22.    * @param {shaka.extern.Variant} root
  23.    *    The variant that all other variants will be tested against when being
  24.    *    added to the adaptation set. If a variant is not compatible with the
  25.    *    root, it will not be added.
  26.    * @param {!Iterable<shaka.extern.Variant>=} candidates
  27.    *    Variants that may be compatible with the root and should be added if
  28.    *    compatible. If a candidate is not compatible, it will not end up in the
  29.    *    adaptation set.
  30.    * @param {boolean=} compareCodecs
  31.    */
  32.   constructor(root, candidates, compareCodecs = true) {
  33.     /** @private {shaka.extern.Variant} */
  34.     this.root_ = root;
  35.     /** @private {!Set<shaka.extern.Variant>} */
  36.     this.variants_ = new Set([root]);
  38.     // Try to add all the candidates. If they cannot be added (because they
  39.     // are not compatible with the root, they will be rejected by |add|.
  40.     candidates = candidates || [];
  41.     for (const candidate of candidates) {
  42.       this.add(candidate, compareCodecs);
  43.     }
  44.   }
  46.   /**
  47.    * @param {shaka.extern.Variant} variant
  48.    * @param {boolean} compareCodecs
  49.    * @return {boolean}
  50.    */
  51.   add(variant, compareCodecs) {
  52.     if (this.canInclude(variant, compareCodecs)) {
  53.       this.variants_.add(variant);
  54.       return true;
  55.     }
  57.     // To be nice, issue a warning if someone is trying to add something that
  58.     // they shouldn't.
  59.     shaka.log.warning('Rejecting variant - not compatible with root.');
  60.     return false;
  61.   }
  63.   /**
  64.    * Check if |variant| can be included with the set. If |canInclude| returns
  65.    * |false|, calling |add| will result in it being ignored.
  66.    *
  67.    * @param {shaka.extern.Variant} variant
  68.    * @param {boolean=} compareCodecs
  69.    * @return {boolean}
  70.    */
  71.   canInclude(variant, compareCodecs = true) {
  72.     return shaka.media.AdaptationSet
  73.         .areAdaptable(this.root_, variant, compareCodecs);
  74.   }
  76.   /**
  77.    * @param {shaka.extern.Variant} a
  78.    * @param {shaka.extern.Variant} b
  79.    * @param {boolean} compareCodecs
  80.    * @return {boolean}
  81.    */
  82.   static areAdaptable(a, b, compareCodecs) {
  83.     const AdaptationSet = shaka.media.AdaptationSet;
  85.     // All variants should have audio or should all not have audio.
  86.     if (!!a.audio != !!b.audio) {
  87.       return false;
  88.     }
  90.     // All variants should have video or should all not have video.
  91.     if (!!a.video != !!b.video) {
  92.       return false;
  93.     }
  95.     // If the languages don't match, we should not adapt between them.
  96.     if (a.language != b.language) {
  97.       return false;
  98.     }
  100.     goog.asserts.assert(
  101.         !!a.audio == !!b.audio,
  102.         'Both should either have audio or not have audio.');
  103.     if (a.audio && b.audio &&
  104.         !AdaptationSet.areAudiosCompatible_(a.audio, b.audio, compareCodecs)) {
  105.       return false;
  106.     }
  108.     goog.asserts.assert(
  109.         !!a.video == !!b.video,
  110.         'Both should either have video or not have video.');
  111.     if (a.video && b.video &&
  112.         !AdaptationSet.areVideosCompatible_(a.video, b.video, compareCodecs)) {
  113.       return false;
  114.     }
  116.     return true;
  117.   }
  119.   /**
  120.    * @return {!Iterable<shaka.extern.Variant>}
  121.    */
  122.   values() {
  123.     return this.variants_.values();
  124.   }
  126.   /**
  127.    * Check if we can switch between two audio streams.
  128.    *
  129.    * @param {shaka.extern.Stream} a
  130.    * @param {shaka.extern.Stream} b
  131.    * @param {boolean} compareCodecs
  132.    * @return {boolean}
  133.    * @private
  134.    */
  135.   static areAudiosCompatible_(a, b, compareCodecs) {
  136.     const AdaptationSet = shaka.media.AdaptationSet;
  138.     // Don't adapt between channel counts, which could annoy the user
  139.     // due to volume changes on downmixing.  An exception is made for
  140.     // stereo and mono, which should be fine to adapt between.
  141.     if (!a.channelsCount || !b.channelsCount ||
  142.         a.channelsCount > 2 || b.channelsCount > 2) {
  143.       if (a.channelsCount != b.channelsCount) {
  144.         return false;
  145.       }
  146.     }
  148.     // Don't adapt between spatial and non spatial audio, which may
  149.     // annoy the user.
  150.     if (a.spatialAudio !== b.spatialAudio) {
  151.       return false;
  152.     }
  154.     // We can only adapt between base-codecs.
  155.     if (compareCodecs && !AdaptationSet.canTransitionBetween_(a, b)) {
  156.       return false;
  157.     }
  159.     // Audio roles must not change between adaptations.
  160.     if (!AdaptationSet.areRolesEqual_(a.roles, b.roles)) {
  161.       return false;
  162.     }
  164.     // We can only adapt between the same groupId.
  165.     if (a.groupId !== b.groupId) {
  166.       return false;
  167.     }
  169.     return true;
  170.   }
  172.   /**
  173.    * Check if we can switch between two video streams.
  174.    *
  175.    * @param {shaka.extern.Stream} a
  176.    * @param {shaka.extern.Stream} b
  177.    * @param {boolean} compareCodecs
  178.    * @return {boolean}
  179.    * @private
  180.    */
  181.   static areVideosCompatible_(a, b, compareCodecs) {
  182.     const AdaptationSet = shaka.media.AdaptationSet;
  184.     // We can only adapt between base-codecs.
  185.     if (compareCodecs && !AdaptationSet.canTransitionBetween_(a, b)) {
  186.       return false;
  187.     }
  189.     // Video roles must not change between adaptations.
  190.     if (!AdaptationSet.areRolesEqual_(a.roles, b.roles)) {
  191.       return false;
  192.     }
  194.     return true;
  195.   }
  197.   /**
  198.    * Check if we can switch between two streams based on their codec and mime
  199.    * type.
  200.    *
  201.    * @param {shaka.extern.Stream} a
  202.    * @param {shaka.extern.Stream} b
  203.    * @return {boolean}
  204.    * @private
  205.    */
  206.   static canTransitionBetween_(a, b) {
  207.     if (a.mimeType != b.mimeType) {
  208.       return false;
  209.     }
  212.     // Get the base codec of each codec in each stream.
  213.     const codecsA = shaka.util.MimeUtils.splitCodecs(a.codecs).map((codec) => {
  214.       return shaka.util.MimeUtils.getCodecBase(codec);
  215.     });
  216.     const codecsB = shaka.util.MimeUtils.splitCodecs(b.codecs).map((codec) => {
  217.       return shaka.util.MimeUtils.getCodecBase(codec);
  218.     });
  220.     // We don't want to allow switching between transmuxed and non-transmuxed
  221.     // content so the number of codecs should be the same.
  222.     //
  223.     // To avoid the case where an codec is used for audio and video we will
  224.     // codecs using arrays (not sets). While at this time, there are no codecs
  225.     // that work for audio and video, it is possible for "raw" codecs to be
  226.     // which would share the same name.
  227.     if (codecsA.length != codecsB.length) {
  228.       return false;
  229.     }
  231.     // Sort them so that we can walk through them and compare them
  232.     // element-by-element.
  233.     codecsA.sort();
  234.     codecsB.sort();
  236.     for (let i = 0; i < codecsA.length; i++) {
  237.       if (codecsA[i] != codecsB[i]) {
  238.         return false;
  239.       }
  240.     }
  242.     return true;
  243.   }
  245.   /**
  246.    * Check if two role lists are the equal. This will take into account all
  247.    * unique behaviours when comparing roles.
  248.    *
  249.    * @param {!Iterable<string>} a
  250.    * @param {!Iterable<string>} b
  251.    * @return {boolean}
  252.    * @private
  253.    */
  254.   static areRolesEqual_(a, b) {
  255.     const aSet = new Set(a);
  256.     const bSet = new Set(b);
  258.     // Remove the main role from the role lists (we expect to see them only
  259.     // in dash manifests).
  260.     const mainRole = 'main';
  261.     aSet.delete(mainRole);
  262.     bSet.delete(mainRole);
  264.     // Make sure that we have the same number roles in each list. Make sure to
  265.     // do it after correcting for 'main'.
  266.     if (aSet.size != bSet.size) {
  267.       return false;
  268.     }
  270.     // Because we know the two sets are the same size, if any item is missing
  271.     // if means that they are not the same.
  272.     for (const x of aSet) {
  273.       if (!bSet.has(x)) {
  274.         return false;
  275.       }
  276.     }
  278.     return true;
  279.   }
  280. };