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